From 19b954fde81d5529ed9d093b430bf938b2156a48 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 22 Nov 2013 22:52:21 -0800 Subject: [PATCH 001/441] Added OperationRepeat & repeat operator --- rxjava-core/src/main/java/rx/Observable.java | 118 ++++-------------- .../java/rx/operators/OperationRepeat.java | 70 +++++++++++ 2 files changed, 95 insertions(+), 93 deletions(-) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationRepeat.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 56a4664654..b53754e697 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -15,83 +15,11 @@ */ package rx; -import static rx.util.functions.Functions.*; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; -import java.util.concurrent.ConcurrentHashMap; -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.OperationAmb; -import rx.operators.OperationAny; -import rx.operators.OperationAverage; -import rx.operators.OperationBuffer; -import rx.operators.OperationCache; -import rx.operators.OperationCast; -import rx.operators.OperationCombineLatest; -import rx.operators.OperationConcat; -import rx.operators.OperationDebounce; -import rx.operators.OperationDefaultIfEmpty; -import rx.operators.OperationDefer; -import rx.operators.OperationDematerialize; -import rx.operators.OperationDistinct; -import rx.operators.OperationDistinctUntilChanged; -import rx.operators.OperationDoOnEach; -import rx.operators.OperationElementAt; -import rx.operators.OperationFilter; -import rx.operators.OperationFinally; -import rx.operators.OperationFirstOrDefault; -import rx.operators.OperationGroupBy; -import rx.operators.OperationInterval; -import rx.operators.OperationLast; -import rx.operators.OperationMap; -import rx.operators.OperationMaterialize; -import rx.operators.OperationMerge; -import rx.operators.OperationMergeDelayError; -import rx.operators.OperationMinMax; -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.OperationParallel; -import rx.operators.OperationParallelMerge; -import rx.operators.OperationRetry; -import rx.operators.OperationSample; -import rx.operators.OperationScan; -import rx.operators.OperationSkip; -import rx.operators.OperationSkipLast; -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.OperationThrottleFirst; -import rx.operators.OperationTimeInterval; -import rx.operators.OperationTimeout; -import rx.operators.OperationTimestamp; -import rx.operators.OperationToObservableFuture; -import rx.operators.OperationToObservableIterable; -import rx.operators.OperationToObservableList; -import rx.operators.OperationToObservableSortedList; -import rx.operators.OperationUsing; -import rx.operators.OperationWindow; -import rx.operators.OperationZip; -import rx.operators.SafeObservableSubscription; -import rx.operators.SafeObserver; +import rx.operators.*; import rx.plugins.RxJavaErrorHandler; import rx.plugins.RxJavaObservableExecutionHook; import rx.plugins.RxJavaPlugins; @@ -100,26 +28,19 @@ 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.TimeInterval; -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; +import rx.util.*; +import rx.util.functions.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +import static rx.util.functions.Functions.alwaysFalse; +import static rx.util.functions.Functions.not; /** * The Observable interface that implements the Reactive Pattern. @@ -1040,6 +961,17 @@ public static Observable range(int start, int count, Scheduler schedule return range(start, count).observeOn(scheduler); } + /** + * Repeats the observable sequence indefinitely. + *

+ * + * @return The observable sequence producing the elements of the given sequence repeatedly and sequentially. + * @see MSDN: Observable.Repeat + */ + public Observable repeat() { + return create(rx.operators.OperationRepeat.repeat(this)); + } + /** * Returns an Observable that calls an Observable factory to create its * Observable for each new Observer that subscribes. That is, for each diff --git a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java new file mode 100644 index 0000000000..61f42be76c --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java @@ -0,0 +1,70 @@ +/** + * 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 rx.Observable; +import rx.Observer; +import rx.Scheduler; +import rx.Subscription; +import rx.concurrency.Schedulers; +import rx.subscriptions.MultipleAssignmentSubscription; +import rx.util.functions.Func2; + +public final class OperationRepeat { + + public static Observable.OnSubscribeFunc repeat(Observable source) { + return new RepeatObservable(source); + } + + static class RepeatObservable implements Observable.OnSubscribeFunc { + + RepeatObservable(Observable source) { + this.source = source; + } + + private Observable source; + private Observer observer; + private MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription(); + + @Override + public Subscription onSubscribe(Observer observer) { + this.observer = observer; + Loop(); + return subscription; + } + + void Loop() { + subscription.setSubscription(Schedulers.currentThread().schedule(0, new Func2() { + @Override + public Subscription call(Scheduler s, Integer n) { + return source.subscribe(new Observer() { + @Override + public void onCompleted() { Loop(); } + + @Override + public void onError(Throwable error) { observer.onError(error); } + + @Override + public void onNext(T value) { observer.onNext(value); } + }); + } + })); + } + } + + +} From 9a6f9cbb2cb7e54e698a01657d59f8ee0ed5f462 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 23 Nov 2013 10:29:20 -0800 Subject: [PATCH 002/441] Added OperationRepeat & repeat operator --- .../java/rx/operators/OperationRepeat.java | 75 +++++++++---------- 1 file changed, 36 insertions(+), 39 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java index 61f42be76c..83c62272b1 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java @@ -18,53 +18,50 @@ import rx.Observable; import rx.Observer; -import rx.Scheduler; import rx.Subscription; import rx.concurrency.Schedulers; -import rx.subscriptions.MultipleAssignmentSubscription; -import rx.util.functions.Func2; +import rx.subscriptions.SerialSubscription; +import rx.util.functions.Action0; +import rx.util.functions.Action1; -public final class OperationRepeat { +public class OperationRepeat implements Observable.OnSubscribeFunc { - public static Observable.OnSubscribeFunc repeat(Observable source) { - return new RepeatObservable(source); - } - - static class RepeatObservable implements Observable.OnSubscribeFunc { + private final Observable source; - RepeatObservable(Observable source) { - this.source = source; - } + public static Observable.OnSubscribeFunc repeat(Observable seed) { + return new OperationRepeat(seed); + } - private Observable source; - private Observer observer; - private MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription(); + private OperationRepeat(Observable source) { + this.source = source; + } - @Override - public Subscription onSubscribe(Observer observer) { - this.observer = observer; - Loop(); - return subscription; - } + @Override + public Subscription onSubscribe(final Observer observer) { + final SerialSubscription subscription = new SerialSubscription(); + subscription.setSubscription(Schedulers.currentThread().schedule(new Action1() { + @Override + public void call(final Action0 self) { + subscription.setSubscription(source.subscribe(new Observer() { - void Loop() { - subscription.setSubscription(Schedulers.currentThread().schedule(0, new Func2() { - @Override - public Subscription call(Scheduler s, Integer n) { - return source.subscribe(new Observer() { - @Override - public void onCompleted() { Loop(); } + @Override + public void onCompleted() { + subscription.getSubscription().unsubscribe(); + self.call(); + } - @Override - public void onError(Throwable error) { observer.onError(error); } + @Override + public void onError(Throwable error) { + observer.onError(error); + } - @Override - public void onNext(T value) { observer.onNext(value); } - }); - } - })); - } + @Override + public void onNext(T value) { + observer.onNext(value); + } + })); + } + })); + return subscription; } - - -} +} \ No newline at end of file From 1a7e51f33a28f9299719252035d6bc218eeedbdd Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 23 Nov 2013 13:22:25 -0800 Subject: [PATCH 003/441] Added test --- rxjava-core/src/main/java/rx/Observable.java | 13 ++++++- .../java/rx/operators/OperationRepeat.java | 17 +++++---- .../src/test/java/rx/ObservableTests.java | 38 +++++++++++-------- 3 files changed, 44 insertions(+), 24 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index b53754e697..ea975bb42e 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -969,7 +969,18 @@ public static Observable range(int start, int count, Scheduler schedule * @see MSDN: Observable.Repeat */ public Observable repeat() { - return create(rx.operators.OperationRepeat.repeat(this)); + return this.repeat(Schedulers.currentThread()); + } + + /** + * Repeats the observable sequence indefinitely. + *

+ * @param scheduler the scheduler to send the values on. + * @return The observable sequence producing the elements of the given sequence repeatedly and sequentially. + * @see MSDN: Observable.Repeat + */ + public Observable repeat(Scheduler scheduler) { + return create(OperationRepeat.repeat(this, scheduler)); } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java index 83c62272b1..6bf34efa78 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java @@ -18,35 +18,36 @@ import rx.Observable; import rx.Observer; +import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; -import rx.subscriptions.SerialSubscription; +import rx.subscriptions.MultipleAssignmentSubscription; import rx.util.functions.Action0; import rx.util.functions.Action1; public class OperationRepeat implements Observable.OnSubscribeFunc { private final Observable source; + private final Scheduler scheduler; - public static Observable.OnSubscribeFunc repeat(Observable seed) { - return new OperationRepeat(seed); + public static Observable.OnSubscribeFunc repeat(Observable source, Scheduler scheduler) { + return new OperationRepeat(source, scheduler); } - private OperationRepeat(Observable source) { + private OperationRepeat(Observable source, Scheduler scheduler) { this.source = source; + this.scheduler = scheduler; } @Override public Subscription onSubscribe(final Observer observer) { - final SerialSubscription subscription = new SerialSubscription(); - subscription.setSubscription(Schedulers.currentThread().schedule(new Action1() { + final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription(); + subscription.setSubscription(scheduler.schedule(new Action1() { @Override public void call(final Action0 self) { subscription.setSubscription(source.subscribe(new Observer() { @Override public void onCompleted() { - subscription.getSubscription().unsubscribe(); self.call(); } diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index 3d718210a1..dcf0fe678b 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -15,35 +15,36 @@ */ package rx; -import static org.junit.Assert.*; -import static org.mockito.Matchers.*; -import static org.mockito.Mockito.*; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.LinkedList; -import java.util.List; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicReference; - import org.junit.Before; import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.MockitoAnnotations; - import rx.Observable.OnSubscribeFunc; +import rx.concurrency.Schedulers; import rx.concurrency.TestScheduler; import rx.observables.ConnectableObservable; import rx.subscriptions.BooleanSubscription; import rx.subscriptions.Subscriptions; -import rx.util.functions.Action0; import rx.util.functions.Action1; import rx.util.functions.Func1; import rx.util.functions.Func2; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.*; + public class ObservableTests { @Mock @@ -958,4 +959,11 @@ public void testRangeWithScheduler() { inOrder.verify(aObserver, times(1)).onCompleted(); inOrder.verifyNoMoreInteractions(); } + + @Test + public void testRepeatTake() { + Observable xs = Observable.from(1,2); + Object[] ys = xs.repeat(Schedulers.newThread()).take(4).toList().toBlockingObservable().last().toArray(); + assertArrayEquals(new Object[]{ 1, 2, 1, 2}, ys); + } } \ No newline at end of file From 8ec1f1179459e79a6451444f560274ea6fc2f5e5 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 5 Dec 2013 19:23:14 -0800 Subject: [PATCH 004/441] Added release notes for Observer. Added missing empty implementations for Observer methods. --- language-adaptors/rxjava-scala/Rationale.md | 2 +- .../rxjava-scala/ReleaseNotes.md | 70 +++++++++++++++++++ .../main/scala/rx/lang/scala/Observer.scala | 10 +-- 3 files changed, 76 insertions(+), 6 deletions(-) create mode 100644 language-adaptors/rxjava-scala/ReleaseNotes.md diff --git a/language-adaptors/rxjava-scala/Rationale.md b/language-adaptors/rxjava-scala/Rationale.md index 5afb2392cc..a8cd47d954 100644 --- a/language-adaptors/rxjava-scala/Rationale.md +++ b/language-adaptors/rxjava-scala/Rationale.md @@ -91,7 +91,7 @@ and consumption of Rx values from Java but not for Scala as a producer. If we take that approach, we can make bindings that feels like a completely native Scala library, without needing any complications of the Scala side. ```scala -object Observer { …} +object Observable { …} trait Observable[+T] { def asJavaObservable: rx.Observable[_ <: T] } diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md new file mode 100644 index 0000000000..e94cb0683a --- /dev/null +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -0,0 +1,70 @@ +RxScala Release Notes +===================== + +This release of the RxScala bindings builds on the previous 0.15 release to make the Rx bindings for Scala +include all Rx types. In particular this release focuses on the `Subject` and `Scheduler` types. +To makes these notes self-contained, we will start with the `Observer[T]` and `Observable[T]` traits +that lay at the heart of Rx. + +In this release we have made the constructor in the companion object `Observer` and the `asJavaObserver` property +in `Observable[T]`private to the Scala bindings package: + +```scala +trait Observer[-T] { + private [scala] def asJavaObserver: rx.Observer[_ >: T] + + def onNext(value: T): Unit + def onError(error: Throwable): Unit + def onCompleted(): Unit +} + +private [scala] object Observer {…} +``` +To create an instance of say `Observer[String]` in user code, you create a new instance of the `Observer` trait +and implement any of the methods that you care about: +```scala + val printObserver = new Observer[String] { + def onNext(value: String): Unit = {...} + def onError(error: Throwable): Unit = {...} + def onCompleted(): Unit = {...} + } +``` +Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` +(for instance `subscribe`) usually come with overloads that accept the individual methods +`onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you. + +In the future we may make the `Observer` companion object public and add overloads to this extent. + +```scala +object Observable {…} +trait Observable[+T] { + def asJavaObservable: rx.Observable[_ <: T] +} + +object Observer {…} +trait Observer[-T] { + def asJavaObserver: rx.Observer[_ >: T] +} +``` + + +object Subject {…} +trait Subject[-T, +R] extends Observable[R] with Observer[T] { + val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] +} + +object Scheduler {…} +trait Scheduler { + def asJavaScheduler: rx.Scheduler; +} + +object Notification {…} +trait Notification[+T] { + def asJavaNotification: rx.Notification[_ <: T] +} + +object Subscription {…} +trait Subscription { + def asJavaSubscription: rx.Subscription +} +``` \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index 68f3e95cd1..286f9389a6 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -39,29 +39,29 @@ trait Observer[-T] { * * The [[rx.lang.scala.Observable]] will not call this method again after it calls either `onCompleted` or `onError`. */ - def onNext(value: T): Unit + def onNext(value: T): Unit = {} /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has experienced an error condition. * * If the [[rx.lang.scala.Observable]] calls this method, it will not thereafter call `onNext` or `onCompleted`. */ - def onError(error: Throwable): Unit + def onError(error: Throwable): Unit = {} /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has finished sending push-based notifications. * * The [[rx.lang.scala.Observable]] will not call this method if it calls `onError`. */ - def onCompleted(): Unit + def onCompleted(): Unit = {} } -object Observer { +private [scala] object Observer { /** * Assume that the underlying rx.Observer does not need to be wrapped. */ - private [scala] def apply[T](observer: rx.Observer[T]) : Observer[T] = { + def apply[T](observer: rx.Observer[T]) : Observer[T] = { new Observer[T] { override def asJavaObserver = observer From 20da54b419ed20445ca79f82220236d0f78392f5 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 5 Dec 2013 19:42:59 -0800 Subject: [PATCH 005/441] Release notes --- .../rxjava-scala/ReleaseNotes.md | 26 ++++++++++++++----- .../main/scala/rx/lang/scala/Observable.scala | 2 +- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index e94cb0683a..d4924e629d 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -7,7 +7,10 @@ To makes these notes self-contained, we will start with the `Observer[T]` and `O that lay at the heart of Rx. In this release we have made the constructor in the companion object `Observer` and the `asJavaObserver` property -in `Observable[T]`private to the Scala bindings package: +in `Observable[T]`private to the Scala bindings package. + +Observer +-------- ```scala trait Observer[-T] { @@ -33,20 +36,29 @@ Note that typically you do not need to create an `Observer` since all of the met (for instance `subscribe`) usually come with overloads that accept the individual methods `onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you. -In the future we may make the `Observer` companion object public and add overloads to this extent. +While *technically* it is a breaking change to make the companion object `Observer` and the `asJavaObserver` property +private, you should probably not have touched `asjavaObserver` in the first place.In the future we may make the +`Observer` companion object public and add overloads that take functions corresponding to the `Observer` methods. + +Observable +---------- + +Just like for `Observer`, the `Observable` trait now also hides its `asJavaObservable` property and makes the constructor +function in the companion object that takes an `rx.Observable` private (but leaves the companion object itself public). +Again, while *technically* this is a breaking change, this should not have any influence on user code. ```scala -object Observable {…} trait Observable[+T] { - def asJavaObservable: rx.Observable[_ <: T] + private [scala] def asJavaObservable: rx.Observable[_ <: T] } -object Observer {…} -trait Observer[-T] { - def asJavaObserver: rx.Observer[_ >: T] +object Observable { + private [scala] def apply[T](observable: rx.Observable[_ <: T]): Observable[T] = {...} } ``` +Subject +------- object Subject {…} trait Subject[-T, +R] extends Observable[R] with Observer[T] { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 396ce1dae8..0846895753 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -79,7 +79,7 @@ trait Observable[+T] import rx.lang.scala.observables.BlockingObservable import rx.lang.scala.ImplicitFunctionConversions._ - def asJavaObservable: rx.Observable[_ <: T] + private [scala] def asJavaObservable: rx.Observable[_ <: T] /** * $subscribeObserverMain From 7737b8dac7af41d28c98df9e323bd3712b00c265 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 5 Dec 2013 19:48:43 -0800 Subject: [PATCH 006/441] Added overrides. --- language-adaptors/rxjava-scala/ReleaseNotes.md | 6 +++--- .../src/main/scala/rx/lang/scala/Observer.scala | 6 +++--- .../rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index d4924e629d..84457ce741 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -27,9 +27,9 @@ To create an instance of say `Observer[String]` in user code, you create a new i and implement any of the methods that you care about: ```scala val printObserver = new Observer[String] { - def onNext(value: String): Unit = {...} - def onError(error: Throwable): Unit = {...} - def onCompleted(): Unit = {...} + override def onNext(value: String): Unit = {...} + override def onError(error: Throwable): Unit = {...} + override def onCompleted(): Unit = {...} } ``` Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index 286f9389a6..74e5602fdd 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -66,9 +66,9 @@ private [scala] object Observer { override def asJavaObserver = observer - def onNext(value: T): Unit = asJavaObserver.onNext(value) - def onError(error: Throwable): Unit = asJavaObserver.onError(error) - def onCompleted(): Unit = asJavaObserver.onCompleted() + override def onNext(value: T): Unit = asJavaObserver.onNext(value) + override def onError(error: Throwable): Unit = asJavaObserver.onError(error) + override def onCompleted(): Unit = asJavaObserver.onCompleted() } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala index d60b2f3c3d..b072523459 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala @@ -32,9 +32,9 @@ trait Subject[-T, +R] extends Observable[R] with Observer[T] { protected def onCompletedCore() = asJavaSubject.onCompleted() } - def onNext(value: T): Unit = asJavaObserver.onNext(value) - def onError(error: Throwable): Unit = asJavaObserver.onError(error) - def onCompleted(): Unit = asJavaObserver.onCompleted() + override def onNext(value: T): Unit = asJavaObserver.onNext(value) + override def onError(error: Throwable): Unit = asJavaObserver.onError(error) + override def onCompleted(): Unit = asJavaObserver.onCompleted() } From fdf68a817756ce9d0f864868919bde90e9a8391d Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 30 Nov 2013 12:58:38 -0800 Subject: [PATCH 007/441] Strange changes ... --- .../rx/lang/scala/examples/Olympics.scala | 14 +- .../rx/lang/scala/examples/RxScalaDemo.scala | 78 ++++---- .../main/scala/rx/lang/scala/Observable.scala | 4 +- .../scala/rx/lang/scala/ObservableTest.scala | 177 +++++++++--------- 4 files changed, 137 insertions(+), 136 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala index 7a11bdf539..c79ef569ca 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala @@ -21,8 +21,8 @@ import scala.concurrent.duration._ object Olympics { case class Medal(val year: Int, val games: String, val discipline: String, val medal: String, val athlete: String, val country: String) - def mountainBikeMedals: Observable[Medal] = Observable( - Observable( + def mountainBikeMedals: Observable[Medal] = Observable.from( + Observable.from( Medal(1996, "Atlanta 1996", "cross-country men", "Gold", "Bart BRENTJENS", "Netherlands"), Medal(1996, "Atlanta 1996", "cross-country women", "Gold", "Paola PEZZO", "Italy"), Medal(1996, "Atlanta 1996", "cross-country men", "Silver", "Thomas FRISCHKNECHT", "Switzerland"), @@ -31,7 +31,7 @@ object Olympics { Medal(1996, "Atlanta 1996", "cross-country women", "Bronze", "Susan DEMATTEI", "United States of America") ), fourYearsEmpty, - Observable( + Observable.from( Medal(2000, "Sydney 2000", "cross-country women", "Gold", "Paola PEZZO", "Italy"), Medal(2000, "Sydney 2000", "cross-country women", "Silver", "Barbara BLATTER", "Switzerland"), Medal(2000, "Sydney 2000", "cross-country women", "Bronze", "Marga FULLANA", "Spain"), @@ -40,7 +40,7 @@ object Olympics { Medal(2000, "Sydney 2000", "cross-country men", "Bronze", "Christoph SAUSER", "Switzerland") ), fourYearsEmpty, - Observable( + Observable.from( Medal(2004, "Athens 2004", "cross-country men", "Gold", "Julien ABSALON", "France"), Medal(2004, "Athens 2004", "cross-country men", "Silver", "Jose Antonio HERMIDA RAMOS", "Spain"), Medal(2004, "Athens 2004", "cross-country men", "Bronze", "Bart BRENTJENS", "Netherlands"), @@ -49,7 +49,7 @@ object Olympics { Medal(2004, "Athens 2004", "cross-country women", "Bronze", "Sabine SPITZ", "Germany") ), fourYearsEmpty, - Observable( + Observable.from( Medal(2008, "Beijing 2008", "cross-country women", "Gold", "Sabine SPITZ", "Germany"), Medal(2008, "Beijing 2008", "cross-country women", "Silver", "Maja WLOSZCZOWSKA", "Poland"), Medal(2008, "Beijing 2008", "cross-country women", "Bronze", "Irina KALENTYEVA", "Russian Federation"), @@ -58,7 +58,7 @@ object Olympics { Medal(2008, "Beijing 2008", "cross-country men", "Bronze", "Nino SCHURTER", "Switzerland") ), fourYearsEmpty, - Observable( + Observable.from( Medal(2012, "London 2012", "cross-country men", "Gold", "Jaroslav KULHAVY", "Czech Republic"), Medal(2012, "London 2012", "cross-country men", "Silver", "Nino SCHURTER", "Switzerland"), Medal(2012, "London 2012", "cross-country men", "Bronze", "Marco Aurelio FONTANA", "Italy"), @@ -80,7 +80,7 @@ object Olympics { // So we don't use this: // Observable.interval(fourYears).take(1).map(i => neverUsedDummyMedal).filter(m => false) // But we just return empty, which completes immediately - Observable() + Observable.from() } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala index be7a30e9d6..8fef6d596e 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala @@ -69,14 +69,14 @@ class RxScalaDemo extends JUnitSuite { } @Test def testSwitchOnObservableOfInt() { - // Correctly rejected with error + // Correctly rejected with error // "Cannot prove that Observable[Int] <:< Observable[Observable[U]]" // val o = Observable(1, 2).switch } @Test def testObservableComparison() { - val first = Observable(10, 11, 12) - val second = Observable(10, 11, 12) + val first = Observable.from(10, 11, 12) + val second = Observable.from(10, 11, 12) val b1 = (first zip second) map (p => p._1 == p._2) forall (b => b) @@ -88,8 +88,8 @@ class RxScalaDemo extends JUnitSuite { } @Test def testObservableComparisonWithForComprehension() { - val first = Observable(10, 11, 12) - val second = Observable(10, 11, 12) + val first = Observable.from(10, 11, 12) + val second = Observable.from(10, 11, 12) val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2) @@ -99,8 +99,8 @@ class RxScalaDemo extends JUnitSuite { } @Test def testStartWithIsUnnecessary() { - val before = Observable(-2, -1, 0) - val source = Observable(1, 2, 3) + val before = Observable.from(-2, -1, 0) + val source = Observable.from(1, 2, 3) println((before ++ source).toBlockingObservable.toList) } @@ -124,7 +124,7 @@ class RxScalaDemo extends JUnitSuite { @Test def fattenSomeExample() { // To merge some observables which are all known already: - Observable( + Observable.from( Observable.interval(200 millis), Observable.interval(400 millis), Observable.interval(800 millis) @@ -144,7 +144,7 @@ class RxScalaDemo extends JUnitSuite { } @Test def testReduce() { - assertEquals(10, Observable(1, 2, 3, 4).reduce(_ + _).toBlockingObservable.single) + assertEquals(10, Observable.from(1, 2, 3, 4).reduce(_ + _).toBlockingObservable.single) } @Test def testForeach() { @@ -158,7 +158,7 @@ class RxScalaDemo extends JUnitSuite { } @Test def testForComprehension() { - val observables = Observable(Observable(1, 2, 3), Observable(10, 20, 30)) + val observables = Observable.from(Observable.from(1, 2, 3), Observable.from(10, 20, 30)) val squares = (for (o <- observables; i <- o if i % 2 == 0) yield i*i) assertEquals(squares.toBlockingObservable.toList, List(4, 100, 400, 900)) } @@ -186,14 +186,14 @@ class RxScalaDemo extends JUnitSuite { } @Test def testGroupByThenFlatMap() { - val m = Observable(1, 2, 3, 4) + val m = Observable.from(1, 2, 3, 4) val g = m.groupBy(i => i % 2) val t = g.flatMap((p: (Int, Observable[Int])) => p._2) assertEquals(List(1, 2, 3, 4), t.toBlockingObservable.toList) } @Test def testGroupByThenFlatMapByForComprehension() { - val m = Observable(1, 2, 3, 4) + val m = Observable.from(1, 2, 3, 4) val g = m.groupBy(i => i % 2) val t = for ((i, o) <- g; n <- o) yield n assertEquals(List(1, 2, 3, 4), t.toBlockingObservable.toList) @@ -288,9 +288,9 @@ class RxScalaDemo extends JUnitSuite { } @Test def testSingleOption() { - assertEquals(None, Observable(1, 2).toBlockingObservable.singleOption) - assertEquals(Some(1), Observable(1) .toBlockingObservable.singleOption) - assertEquals(None, Observable() .toBlockingObservable.singleOption) + assertEquals(None, Observable.from(1, 2).toBlockingObservable.singleOption) + assertEquals(Some(1), Observable.from(1) .toBlockingObservable.singleOption) + assertEquals(None, Observable.from() .toBlockingObservable.singleOption) } // We can't put a general average method into Observable.scala, because Scala's Numeric @@ -301,58 +301,58 @@ class RxScalaDemo extends JUnitSuite { } @Test def averageExample() { - println(doubleAverage(Observable()).toBlockingObservable.single) - println(doubleAverage(Observable(0)).toBlockingObservable.single) - println(doubleAverage(Observable(4.44)).toBlockingObservable.single) - println(doubleAverage(Observable(1, 2, 3.5)).toBlockingObservable.single) + println(doubleAverage(Observable.from()).toBlockingObservable.single) + println(doubleAverage(Observable.from(0)).toBlockingObservable.single) + println(doubleAverage(Observable.from(4.44)).toBlockingObservable.single) + println(doubleAverage(Observable.from(1, 2, 3.5)).toBlockingObservable.single) } @Test def testSum() { - assertEquals(10, Observable(1, 2, 3, 4).sum.toBlockingObservable.single) - assertEquals(6, Observable(4, 2).sum.toBlockingObservable.single) - assertEquals(0, Observable[Int]().sum.toBlockingObservable.single) + assertEquals(10, Observable.from(1, 2, 3, 4).sum.toBlockingObservable.single) + assertEquals(6, Observable.from(4, 2).sum.toBlockingObservable.single) + assertEquals(0, Observable.from[Int]().sum.toBlockingObservable.single) } @Test def testProduct() { - assertEquals(24, Observable(1, 2, 3, 4).product.toBlockingObservable.single) - assertEquals(8, Observable(4, 2).product.toBlockingObservable.single) - assertEquals(1, Observable[Int]().product.toBlockingObservable.single) + assertEquals(24, Observable.from(1, 2, 3, 4).product.toBlockingObservable.single) + assertEquals(8, Observable.from(4, 2).product.toBlockingObservable.single) + assertEquals(1, Observable.from[Int]().product.toBlockingObservable.single) } @Test def mapWithIndexExample() { // We don't need mapWithIndex because we already have zipWithIndex, which we can easily // combine with map: - Observable("a", "b", "c").zipWithIndex.map(pair => pair._1 + " has index " + pair._2) + Observable.from("a", "b", "c").zipWithIndex.map(pair => pair._1 + " has index " + pair._2) .toBlockingObservable.foreach(println(_)) // Or even nicer with for-comprehension syntax: - (for ((letter, index) <- Observable("a", "b", "c").zipWithIndex) yield letter + " has index " + index) + (for ((letter, index) <- Observable.from("a", "b", "c").zipWithIndex) yield letter + " has index " + index) .toBlockingObservable.foreach(println(_)) } // source Observables are all known: @Test def zip3Example() { - val o = Observable.zip(Observable(1, 2), Observable(10, 20), Observable(100, 200)) + val o = Observable.zip(Observable.from(1, 2), Observable.from(10, 20), Observable.from(100, 200)) (for ((n1, n2, n3) <- o) yield s"$n1, $n2 and $n3") .toBlockingObservable.foreach(println(_)) } // source Observables are in an Observable: @Test def zipManyObservableExample() { - val observables = Observable(Observable(1, 2), Observable(10, 20), Observable(100, 200)) + val observables = Observable.from(Observable.from(1, 2), Observable.from(10, 20), Observable.from(100, 200)) (for (seq <- Observable.zip(observables)) yield seq.mkString("(", ", ", ")")) .toBlockingObservable.foreach(println(_)) } @Test def takeFirstWithCondition() { val condition: Int => Boolean = _ >= 3 - assertEquals(3, Observable(1, 2, 3, 4).filter(condition).first.toBlockingObservable.single) + assertEquals(3, Observable.from(1, 2, 3, 4).filter(condition).first.toBlockingObservable.single) } @Test def firstOrDefaultWithCondition() { val condition: Int => Boolean = _ >= 3 - assertEquals(3, Observable(1, 2, 3, 4).filter(condition).firstOrElse(10).toBlockingObservable.single) - assertEquals(10, Observable(-1, 0, 1).filter(condition).firstOrElse(10).toBlockingObservable.single) + assertEquals(3, Observable.from(1, 2, 3, 4).filter(condition).firstOrElse(10).toBlockingObservable.single) + assertEquals(10, Observable.from(-1, 0, 1).filter(condition).firstOrElse(10).toBlockingObservable.single) } def square(x: Int): Int = { @@ -379,9 +379,9 @@ class RxScalaDemo extends JUnitSuite { } @Test def toSortedList() { - assertEquals(Seq(7, 8, 9, 10), Observable(10, 7, 8, 9).toSeq.map(_.sorted).toBlockingObservable.single) + assertEquals(Seq(7, 8, 9, 10), Observable.from(10, 7, 8, 9).toSeq.map(_.sorted).toBlockingObservable.single) val f = (a: Int, b: Int) => b < a - assertEquals(Seq(10, 9, 8, 7), Observable(10, 7, 8, 9).toSeq.map(_.sortWith(f)).toBlockingObservable.single) + assertEquals(Seq(10, 9, 8, 7), Observable.from(10, 7, 8, 9).toSeq.map(_.sortWith(f)).toBlockingObservable.single) } @Test def timestampExample() { @@ -411,7 +411,7 @@ class RxScalaDemo extends JUnitSuite { @Test def materializeExample2() { import Notification._ - Observable(1, 2, 3).materialize.subscribe(n => n match { + Observable.from(1, 2, 3).materialize.subscribe(n => n match { case OnNext(v) => println("Got value " + v) case OnCompleted() => println("Completed") case OnError(err) => println("Error: " + err.getMessage) @@ -419,17 +419,17 @@ class RxScalaDemo extends JUnitSuite { } @Test def elementAtReplacement() { - assertEquals("b", Observable("a", "b", "c").drop(1).first.toBlockingObservable.single) + assertEquals("b", Observable.from("a", "b", "c").drop(1).first.toBlockingObservable.single) } @Test def elementAtOrDefaultReplacement() { - assertEquals("b", Observable("a", "b", "c").drop(1).firstOrElse("!").toBlockingObservable.single) - assertEquals("!!", Observable("a", "b", "c").drop(10).firstOrElse("!!").toBlockingObservable.single) + assertEquals("b", Observable.from("a", "b", "c").drop(1).firstOrElse("!").toBlockingObservable.single) + assertEquals("!!", Observable.from("a", "b", "c").drop(10).firstOrElse("!!").toBlockingObservable.single) } @Test def takeWhileWithIndexAlternative { val condition = true - Observable("a", "b").zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1) + Observable.from("a", "b").zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1) } def output(s: String): Unit = println(s) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 0846895753..8a13e83fb6 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -839,7 +839,7 @@ trait Observable[+T] val o1: Observable[Notification[U]] = this val o2: Observable[rx.Notification[_ <: U]] = o1.map(_.asJava) val o3 = o2.asJavaObservable.dematerialize[U]() - Observable[U](o3) + Observable(o3) } /** @@ -1933,7 +1933,7 @@ object Observable { * resulting Observable * @return an Observable that emits each item in the source Array */ - def apply[T](items: T*): Observable[T] = { + def from[T](items: T*): Observable[T] = { Observable[T](rx.Observable.from(items.toIterable.asJava)) } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index 21f272d03b..25727f7330 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -1,88 +1,89 @@ -package rx.lang.scala - -import org.junit.Assert._ -import org.junit.{ Ignore, Test } -import org.scalatest.junit.JUnitSuite - -class ObservableTests extends JUnitSuite { - - // Tests which needn't be run: - - @Ignore - def testCovariance = { - //println("hey, you shouldn't run this test") - - val o1: Observable[Nothing] = Observable() - val o2: Observable[Int] = o1 - val o3: Observable[App] = o1 - val o4: Observable[Any] = o2 - val o5: Observable[Any] = o3 - } - - // Tests which have to be run: - - @Test - def testDematerialize() { - val o = Observable(1, 2, 3) - val mat = o.materialize - val demat = mat.dematerialize - - // correctly rejected: - //val wrongDemat = Observable("hello").dematerialize - - assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) - } - - // Test that Java's firstOrDefault propagates errors. - // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse - // should be changed accordingly. - @Test def testJavaFirstOrDefault() { - assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable.single) - assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable.single) - val msg = "msg6251" - var receivedMsg = "none" - try { - rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable.single - } catch { - case e: Exception => receivedMsg = e.getCause.getMessage - } - assertEquals(receivedMsg, msg) - } - - @Test def testFirstOrElse() { - def mustNotBeCalled: String = sys.error("this method should not be called") - def mustBeCalled: String = "this is the default value" - assertEquals("hello", Observable("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) - assertEquals("this is the default value", Observable().firstOrElse(mustBeCalled).toBlockingObservable.single) - } - - @Test def testFirstOrElseWithError() { - val msg = "msg6251" - var receivedMsg = "none" - try { - Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single - } catch { - case e: Exception => receivedMsg = e.getCause.getMessage - } - assertEquals(receivedMsg, msg) - } - - /* - @Test def testHead() { - val observer = mock(classOf[Observer[Int]]) - val o = Observable().head - val sub = o.subscribe(observer) - - verify(observer, never).onNext(any(classOf[Int])) - verify(observer, never).onCompleted() - verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) - } - */ - - @Test def testTest() = { - val a: Observable[Int] = Observable() - assertEquals(4, Observable(1, 2, 3, 4).toBlockingObservable.toIterable.last) - //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") - } - -} +//package rx.lang.scala +// +//import org.junit.Assert._ +//import org.junit.{ Ignore, Test } +//import org.scalatest.junit.JUnitSuite +// +//@Ignore +//class ObservableTests extends JUnitSuite { +// +// // Tests which needn't be run: +// +// @Ignore +// def testCovariance = { +// //println("hey, you shouldn't run this test") +// +// val o1: Observable[Nothing] = Observable.from() +// val o2: Observable[Int] = o1 +// val o3: Observable[App] = o1 +// val o4: Observable[Any] = o2 +// val o5: Observable[Any] = o3 +// } +// +// // Tests which have to be run: +// +// //@Test +// //def testDematerialize() { +// //val o = Observable.from(1, 2, 3) +// //val mat = o.materialize +// //val demat = mat.dematerialize +// +// // correctly rejected: +// //val wrongDemat = Observable("hello").dematerialize +// +// //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) +// // } +// +// // Test that Java's firstOrDefault propagates errors. +// // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse +// // should be changed accordingly. +// @Test def testJavaFirstOrDefault() { +// assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) +// assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) +// val msg = "msg6251" +// var receivedMsg = "none" +// try { +// rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single +// } catch { +// case e: Exception => receivedMsg = e.getCause().getMessage() +// } +// assertEquals(receivedMsg, msg) +// } +// +// // @Test def testFirstOrElse() { +//// def mustNotBeCalled: String = sys.error("this method should not be called") +//// def mustBeCalled: String = "this is the default value" +//// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) +//// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) +// // } +// +// @Test def testTestWithError() { +// val msg = "msg6251" +// var receivedMsg = "none" +// try { +// Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single +// } catch { +// case e: Exception => receivedMsg = e.getCause().getMessage() +// } +// assertEquals(receivedMsg, msg) +// } +// +// /* +// @Test def testHead() { +// val observer = mock(classOf[Observer[Int]]) +// val o = Observable().head +// val sub = o.subscribe(observer) +// +// verify(observer, never).onNext(any(classOf[Int])) +// verify(observer, never).onCompleted() +// verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) +// } +// */ +// +// //@Test def testTest() = { +// //val a: Observable[Int] = Observable.from() +// //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) +// //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") +// //} +// +//} From 340b3c18bae1049ab284e22e8358ce3238b83a6c Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 5 Dec 2013 21:40:51 -0800 Subject: [PATCH 008/441] Removing BooleanSubscription --- .../rxjava-scala/ReleaseNotes.md | 83 +++++++- .../main/scala/rx/lang/scala/Observable.scala | 4 + .../main/scala/rx/lang/scala/Scheduler.scala | 9 +- .../main/scala/rx/lang/scala/Subject.scala | 2 +- .../scala/rx/lang/scala/Subscription.scala | 30 ++- .../subscriptions/BooleanSubscription.scala | 8 +- .../subscriptions/CompositeSubscription.scala | 8 +- .../MultiAssignmentSubscription.scala | 8 +- .../subscriptions/SerialSubscription.scala | 11 +- .../scala/rx/lang/scala/ObservableTest.scala | 178 +++++++++--------- 10 files changed, 200 insertions(+), 141 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 84457ce741..72183163fd 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -6,12 +6,12 @@ include all Rx types. In particular this release focuses on the `Subject` and `S To makes these notes self-contained, we will start with the `Observer[T]` and `Observable[T]` traits that lay at the heart of Rx. -In this release we have made the constructor in the companion object `Observer` and the `asJavaObserver` property -in `Observable[T]`private to the Scala bindings package. - Observer -------- +In this release we have made the constructor in the companion object `Observer` and the `asJavaObserver` property +in `Observable[T]`private to the Scala bindings package. + ```scala trait Observer[-T] { private [scala] def asJavaObserver: rx.Observer[_ >: T] @@ -23,6 +23,7 @@ trait Observer[-T] { private [scala] object Observer {…} ``` + To create an instance of say `Observer[String]` in user code, you create a new instance of the `Observer` trait and implement any of the methods that you care about: ```scala @@ -32,6 +33,7 @@ and implement any of the methods that you care about: override def onCompleted(): Unit = {...} } ``` + Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` (for instance `subscribe`) usually come with overloads that accept the individual methods `onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you. @@ -57,19 +59,86 @@ object Observable { } ``` +The major changes in `Observable` are wrt to the factory methods *Can't write this when I don't have Samuel's changes*. + Subject ------- -object Subject {…} +The `Subject` trait now also hides the underlying Java `asJavaSubject: rx.subjects.Subject[_ >: T, _<: R]`. + +```scala trait Subject[-T, +R] extends Observable[R] with Observer[T] { - val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] + private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] } +``` + +There is no companion object for `Subject` but instead there are a number of subtypes for each kind of subject, +that follows the pattern of a companion object and a class with a private constructor: + +```scala +object XXXSubject { + def apply[T](...): XXXSubject[T] = { + new XXXSubject[T](... create corresponding rx subject ...) + } +} + +class XXXSubject[T] private[scala] (val asJavaSubject: rx.subjects.XXXSubject[T]) extends Subject[T,T] {} +``` -object Scheduler {…} +The subjects that are available are: + +* AsyncSubject[T]() +* BehaviorSubject[T](T value) +* PublishSubject[T]() +* ReplaySubject[T]() + +The latter is still missing various overloads http://msdn.microsoft.com/en-us/library/hh211810(v=vs.103).aspx which +you can expect to appear once they are added to the underlying RxJava implementation. + +Compared with release 0.15.1 there are no breaking changes in `Subject` for this release, except for +making `asJavaSubject` private. + +Schedulers +---------- + +The biggest breaking change compared to the 0.15.1 release is giving `Scheduler` the same structure as the other types. +The trait itself remains unchanged, except that we made the underlying Java representation hidden as above. + +```scala trait Scheduler { - def asJavaScheduler: rx.Scheduler; + private[scala] def asJavaScheduler: rx.Scheduler; } +private [scala] object Scheduler {…} +``` + +In the previous release, you created schedulers by selecting them from the `Schedulers` object, +as in `Schedulers.immediate` or `Schedulers.newThread` where each would return an instance of the `Scheduler` trait. +However, several of the scheduler implementations have additional methods, such as the `testScheduler`, +which already deviated from the pattern. + +In this release, we changed this to make scheduler more like `Subject` and provide a family of schedulers +that you create using their factory function: + +* CurrentThreadScheduler() +* ExecutorScheduler(executor: Executor) +* ImmediateScheduler() +* NewThreadScheduler() +* ScheduledExecutorServiceScheduler(executor: ScheduledExecutorService) +* TestScheduler() +* ThreadPoolForComputationScheduler() +* ThreadPoolForIOScheduler() + +In the future we expect that this list will grow further. + +To make your code compile in the new release you will have to change all occurrences of `Schedulers.xxx` +into `XxxScheduler()`. + + +Notifications +------------- + +```scala object Notification {…} trait Notification[+T] { def asJavaNotification: rx.Notification[_ <: T] diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 8a13e83fb6..a559daf360 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -1933,6 +1933,10 @@ object Observable { * resulting Observable * @return an Observable that emits each item in the source Array */ + def apply[T](items: T*): Observable[T] = { + Observable[T](rx.Observable.from(items.toIterable.asJava)) + } + def from[T](items: T*): Observable[T] = { Observable[T](rx.Observable.from(items.toIterable.asJava)) } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 4f1f89e808..0098fc8954 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -25,7 +25,7 @@ import rx.util.functions.{Action0, Action1, Func2} trait Scheduler { import rx.lang.scala.ImplicitFunctionConversions._ - val asJavaScheduler: rx.Scheduler + private [scala] val asJavaScheduler: rx.Scheduler /** * Schedules a cancelable action to be executed. @@ -75,8 +75,7 @@ trait Scheduler { * @return a subscription to be able to unsubscribe from action. */ private def schedule[T](state: T, action: (Scheduler, T) => Subscription, delayTime: Duration): Subscription = { - val xxx = schedulerActionToFunc2(action) - Subscription(asJavaScheduler.schedule(state, xxx, delayTime.length, delayTime.unit)) + Subscription(asJavaScheduler.schedule(state, schedulerActionToFunc2(action), delayTime.length, delayTime.unit)) } /** @@ -213,8 +212,8 @@ trait Scheduler { } -object Scheduler { - private [scala] def apply(scheduler: rx.Scheduler): Scheduler = { +private [scala] object Scheduler { + def apply(scheduler: rx.Scheduler): Scheduler = { new Scheduler() { val asJavaScheduler = scheduler } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala index b072523459..e4534b8055 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala @@ -21,7 +21,7 @@ import rx.joins.ObserverBase * A Subject is an Observable and an Observer at the same time. */ trait Subject[-T, +R] extends Observable[R] with Observer[T] { - val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] + private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] def asJavaObservable: rx.Observable[_ <: R] = asJavaSubject diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index 93e76e4524..1398935e42 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -17,34 +17,41 @@ package rx.lang.scala +import java.util.concurrent.atomic.AtomicBoolean +import rx.lang.scala.subscriptions._ + /** * Subscriptions are returned from all `Observable.subscribe` methods to allow unsubscribing. * * This interface is the equivalent of `IDisposable` in the .NET Rx implementation. */ trait Subscription { - val asJavaSubscription: rx.Subscription + private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { + override def unsubscribe(){ this.unsubscribe(); unsubscribed.set(true) } + } /** * Call this method to stop receiving notifications on the Observer that was registered when * this Subscription was received. */ - def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + def unsubscribe(): Unit /** * Checks if the subscription is unsubscribed. + * You typically do not want to override this. */ - def isUnsubscribed: Boolean + def isUnsubscribed: Boolean = unsubscribed.get() + private [scala] val unsubscribed = new AtomicBoolean(false) + } object Subscription { import java.util.concurrent.atomic.AtomicBoolean - import rx.lang.scala.subscriptions._ /** - * Creates an [[rx.lang.scala.Subscription]] from an [[rx.Subscription]]. + * Creates an [[rx.lang.scala.Subscription]] from an [[rx.Subscription]]. ß */ private [scala] def apply(subscription: rx.Subscription): Subscription = { subscription match { @@ -59,17 +66,8 @@ object Subscription { /** * Creates an [[rx.lang.scala.Subscription]] that invokes the specified action when unsubscribed. */ - def apply(u: => Unit): Subscription = { - new Subscription() { - - private val unsubscribed = new AtomicBoolean(false) - - def isUnsubscribed = unsubscribed.get() - - val asJavaSubscription = new rx.Subscription { - def unsubscribe() { if(!unsubscribed.get()) { u ; unsubscribed.set(true) }} - } - } + def apply(u: => Unit): Subscription = new Subscription { + def unsubscribe() = { u } } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index a9f2070345..ec363c5f6a 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -17,7 +17,7 @@ package rx.lang.scala.subscriptions import rx.lang.scala._ -object BooleanSubscription { +private [scala] object BooleanSubscription { /** * Creates a [[rx.lang.scala.subscriptions.BooleanSubscription]]. @@ -44,12 +44,12 @@ object BooleanSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class BooleanSubscription private[scala] (val asJavaSubscription: rx.subscriptions.BooleanSubscription) +private [scala] class BooleanSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.BooleanSubscription) extends Subscription { /** * Checks whether the subscription has been unsubscribed. */ - def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed - + override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed + def unsubscribe(): Unit = asJavaSubscription.unsubscribe() } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala index 1fe4a4afa5..eaff693f21 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala @@ -44,7 +44,7 @@ object CompositeSubscription { /** * Represents a group of [[rx.lang.scala.Subscription]] that are disposed together. */ -class CompositeSubscription private[scala] (val asJavaSubscription: rx.subscriptions.CompositeSubscription) +class CompositeSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.CompositeSubscription) extends Subscription { /** @@ -68,9 +68,7 @@ class CompositeSubscription private[scala] (val asJavaSubscription: rx.subscript this } - /** - * Checks whether the subscription has been unsubscribed. - */ - def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed + def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala index 84740870c7..b7038a655d 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala @@ -41,7 +41,7 @@ object MultipleAssignmentSubscription { /** * Represents a [[rx.lang.scala.Subscription]] whose underlying subscription can be swapped for another subscription. */ -class MultipleAssignmentSubscription private[scala] (val asJavaSubscription: rx.subscriptions.MultipleAssignmentSubscription) +class MultipleAssignmentSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.MultipleAssignmentSubscription) extends Subscription { /** @@ -59,10 +59,8 @@ class MultipleAssignmentSubscription private[scala] (val asJavaSubscription: rx. this } - /** - * Checks whether the subscription has been unsubscribed. - */ - def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed + def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index 94b50f93e8..3401b87236 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -41,20 +41,13 @@ object SerialSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class SerialSubscription private[scala] (val asJavaSubscription: rx.subscriptions.SerialSubscription) +class SerialSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.SerialSubscription) extends Subscription { - private val unsubscribed = new AtomicBoolean(false) - - /** - * Checks whether the subscription has been unsubscribed. - */ - def isUnsubscribed: Boolean = unsubscribed.get() - /** * Unsubscribes this subscription, setting isUnsubscribed to true. */ - override def unsubscribe(): Unit = { super.unsubscribe(); unsubscribed.set(true) } + override def unsubscribe(): Unit = { asJavaSubscription.unsubscribe(); unsubscribed.set(true) } def subscription_=(value: Subscription): Unit = asJavaSubscription.setSubscription(value.asJavaSubscription) def subscription: Subscription = Subscription(asJavaSubscription.getSubscription) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index 25727f7330..60ff52dfa2 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -1,89 +1,89 @@ -//package rx.lang.scala -// -//import org.junit.Assert._ -//import org.junit.{ Ignore, Test } -//import org.scalatest.junit.JUnitSuite -// -//@Ignore -//class ObservableTests extends JUnitSuite { -// -// // Tests which needn't be run: -// -// @Ignore -// def testCovariance = { -// //println("hey, you shouldn't run this test") -// -// val o1: Observable[Nothing] = Observable.from() -// val o2: Observable[Int] = o1 -// val o3: Observable[App] = o1 -// val o4: Observable[Any] = o2 -// val o5: Observable[Any] = o3 -// } -// -// // Tests which have to be run: -// -// //@Test -// //def testDematerialize() { -// //val o = Observable.from(1, 2, 3) -// //val mat = o.materialize -// //val demat = mat.dematerialize -// -// // correctly rejected: -// //val wrongDemat = Observable("hello").dematerialize -// -// //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) -// // } -// -// // Test that Java's firstOrDefault propagates errors. -// // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse -// // should be changed accordingly. -// @Test def testJavaFirstOrDefault() { -// assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) -// assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) -// val msg = "msg6251" -// var receivedMsg = "none" -// try { -// rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single -// } catch { -// case e: Exception => receivedMsg = e.getCause().getMessage() -// } -// assertEquals(receivedMsg, msg) -// } -// -// // @Test def testFirstOrElse() { -//// def mustNotBeCalled: String = sys.error("this method should not be called") -//// def mustBeCalled: String = "this is the default value" -//// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) -//// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) -// // } -// -// @Test def testTestWithError() { -// val msg = "msg6251" -// var receivedMsg = "none" -// try { -// Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single -// } catch { -// case e: Exception => receivedMsg = e.getCause().getMessage() -// } -// assertEquals(receivedMsg, msg) -// } -// -// /* -// @Test def testHead() { -// val observer = mock(classOf[Observer[Int]]) -// val o = Observable().head -// val sub = o.subscribe(observer) -// -// verify(observer, never).onNext(any(classOf[Int])) -// verify(observer, never).onCompleted() -// verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) -// } -// */ -// -// //@Test def testTest() = { -// //val a: Observable[Int] = Observable.from() -// //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) -// //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") -// //} -// -//} +package rx.lang.scala + +import org.junit.Assert._ +import org.junit.{ Ignore, Test } +import org.scalatest.junit.JUnitSuite + +@Ignore +class ObservableTests extends JUnitSuite { + + // Tests which needn't be run: + + @Ignore + def testCovariance = { + //println("hey, you shouldn't run this test") + + val o1: Observable[Nothing] = Observable.from() + val o2: Observable[Int] = o1 + val o3: Observable[App] = o1 + val o4: Observable[Any] = o2 + val o5: Observable[Any] = o3 + } + + // Tests which have to be run: + + //@Test + //def testDematerialize() { + //val o = Observable.from(1, 2, 3) + //val mat = o.materialize + //val demat = mat.dematerialize + + // correctly rejected: + //val wrongDemat = Observable("hello").dematerialize + + //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) + // } + + // Test that Java's firstOrDefault propagates errors. + // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse + // should be changed accordingly. + @Test def testJavaFirstOrDefault() { + assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) + assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) + val msg = "msg6251" + var receivedMsg = "none" + try { + rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single + } catch { + case e: Exception => receivedMsg = e.getCause().getMessage() + } + assertEquals(receivedMsg, msg) + } + + // @Test def testFirstOrElse() { +// def mustNotBeCalled: String = sys.error("this method should not be called") +// def mustBeCalled: String = "this is the default value" +// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) +// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) + // } + + @Test def testTestWithError() { + val msg = "msg6251" + var receivedMsg = "none" + try { + Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single + } catch { + case e: Exception => receivedMsg = e.getCause().getMessage() + } + assertEquals(receivedMsg, msg) + } + + /* + @Test def testHead() { + val observer = mock(classOf[Observer[Int]]) + val o = Observable().head + val sub = o.subscribe(observer) + + verify(observer, never).onNext(any(classOf[Int])) + verify(observer, never).onCompleted() + verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) + } + */ + + //@Test def testTest() = { + //val a: Observable[Int] = Observable.from() + //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) + //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") + //} + +} From b61388f250e4e3f3c809bae1ed6ab76ced5a4c7f Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 5 Dec 2013 23:14:40 -0800 Subject: [PATCH 009/441] Making tests work --- .../scala/rx/lang/scala/Subscription.scala | 32 ++-- .../subscriptions/BooleanSubscription.scala | 11 +- .../subscriptions/CompositeSubscription.scala | 8 +- .../MultiAssignmentSubscription.scala | 6 +- .../subscriptions/SerialSubscription.scala | 7 +- .../subscriptions/SubscriptionTests.scala | 160 +++++++++--------- 6 files changed, 114 insertions(+), 110 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index 1398935e42..dde7da2f39 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -18,7 +18,6 @@ package rx.lang.scala import java.util.concurrent.atomic.AtomicBoolean -import rx.lang.scala.subscriptions._ /** * Subscriptions are returned from all `Observable.subscribe` methods to allow unsubscribing. @@ -26,15 +25,19 @@ import rx.lang.scala.subscriptions._ * This interface is the equivalent of `IDisposable` in the .NET Rx implementation. */ trait Subscription { - private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { - override def unsubscribe(){ this.unsubscribe(); unsubscribed.set(true) } + + private [scala] def asJavaSubscription: rx.Subscription = new rx.Subscription { + override def unsubscribe(){ + Subscription.this.unsubscribe(); + Subscription.this.unsubscribed.set(true) + } } /** * Call this method to stop receiving notifications on the Observer that was registered when * this Subscription was received. */ - def unsubscribe(): Unit + def unsubscribe(): Unit = { } /** * Checks if the subscription is unsubscribed. @@ -47,27 +50,28 @@ trait Subscription { object Subscription { - import java.util.concurrent.atomic.AtomicBoolean - /** * Creates an [[rx.lang.scala.Subscription]] from an [[rx.Subscription]]. ß */ private [scala] def apply(subscription: rx.Subscription): Subscription = { - subscription match { - case x: rx.subscriptions.BooleanSubscription => new BooleanSubscription(x) - case x: rx.subscriptions.CompositeSubscription => new CompositeSubscription(x) - case x: rx.subscriptions.MultipleAssignmentSubscription => new MultipleAssignmentSubscription(x) - case x: rx.subscriptions.SerialSubscription => new SerialSubscription(x) + /*subscription match { + case x: rx.subscriptions.BooleanSubscription => new rx.lang.scala.subscriptions.BooleanSubscription(x) + case x: rx.subscriptions.CompositeSubscription => new rx.lang.scala.subscriptions.CompositeSubscription(x) + case x: rx.subscriptions.MultipleAssignmentSubscription => new rx.lang.scala.subscriptions.MultipleAssignmentSubscription(x) + case x: rx.subscriptions.SerialSubscription => new rx.lang.scala.subscriptions.SerialSubscription(x) case x: rx.Subscription => apply { x.unsubscribe() } - } + }*/ + apply { subscription.unsubscribe() } } /** * Creates an [[rx.lang.scala.Subscription]] that invokes the specified action when unsubscribed. */ - def apply(u: => Unit): Subscription = new Subscription { - def unsubscribe() = { u } + def apply(u: => Unit): Subscription = { + new Subscription() { + override def unsubscribe(): Unit = { u } + } } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index ec363c5f6a..20d90dfa3d 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -32,10 +32,7 @@ private [scala] object BooleanSubscription { def apply(u: => Unit): BooleanSubscription = { new BooleanSubscription(new rx.subscriptions.BooleanSubscription { override def unsubscribe(): Unit = { - if(!super.isUnsubscribed) { - u - super.unsubscribe() - } + if(!super.isUnsubscribed) { u; super.unsubscribe() } } }) } @@ -44,12 +41,14 @@ private [scala] object BooleanSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -private [scala] class BooleanSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.BooleanSubscription) +private [scala] class BooleanSubscription private[scala] (subscription: rx.subscriptions.BooleanSubscription) extends Subscription { + override def asJavaSubscription = subscription + /** * Checks whether the subscription has been unsubscribed. */ override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed - def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def unsubscribe(): Unit = asJavaSubscription.unsubscribe() } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala index eaff693f21..8baeca26a7 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala @@ -36,7 +36,7 @@ object CompositeSubscription { /** * Creates a [[rx.lang.scala.subscriptions.CompositeSubscription]]. */ - def apply(subscription: rx.subscriptions.CompositeSubscription): CompositeSubscription = { + private [scala] def apply(subscription: rx.subscriptions.CompositeSubscription): CompositeSubscription = { new CompositeSubscription(subscription) } } @@ -44,9 +44,9 @@ object CompositeSubscription { /** * Represents a group of [[rx.lang.scala.Subscription]] that are disposed together. */ -class CompositeSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.CompositeSubscription) - extends Subscription +class CompositeSubscription private[scala] (subscription: rx.subscriptions.CompositeSubscription) extends Subscription { + override def asJavaSubscription = subscription /** * Adds a subscription to the group, * or unsubscribes immediately is the [[rx.subscriptions.CompositeSubscription]] is unsubscribed. @@ -68,7 +68,7 @@ class CompositeSubscription private[scala] (override val asJavaSubscription: rx. this } - def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def unsubscribe(): Unit = asJavaSubscription.unsubscribe() override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala index b7038a655d..c53d663c50 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala @@ -41,9 +41,9 @@ object MultipleAssignmentSubscription { /** * Represents a [[rx.lang.scala.Subscription]] whose underlying subscription can be swapped for another subscription. */ -class MultipleAssignmentSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.MultipleAssignmentSubscription) - extends Subscription { +class MultipleAssignmentSubscription private[scala] (s: rx.subscriptions.MultipleAssignmentSubscription) extends Subscription { + override def asJavaSubscription = s /** * Gets the underlying subscription. */ @@ -59,7 +59,7 @@ class MultipleAssignmentSubscription private[scala] (override val asJavaSubscrip this } - def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def unsubscribe(): Unit = asJavaSubscription.unsubscribe() override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index 3401b87236..765f3c4240 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -15,8 +15,7 @@ */ package rx.lang.scala.subscriptions -import rx.lang.scala.Subscription -import java.util.concurrent.atomic.AtomicBoolean +import rx.lang.scala._ object SerialSubscription { @@ -41,9 +40,9 @@ object SerialSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class SerialSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.SerialSubscription) - extends Subscription { +class SerialSubscription private[scala] (s: rx.subscriptions.SerialSubscription) extends Subscription { + override def asJavaSubscription = s /** * Unsubscribes this subscription, setting isUnsubscribed to true. */ diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala index 25891e1a9f..baa6142b98 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala @@ -1,119 +1,121 @@ -package rx.lang.scala.subscriptions +package rx.lang.scala.subscriptionstest import org.junit.Assert._ import org.junit.Test import org.scalatest.junit.JUnitSuite -import rx.lang.scala._ - +import rx.lang.scala +import rx.lang.scala.Subscription +import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription, BooleanSubscription} class SubscriptionTests extends JUnitSuite { @Test def anonymousSubscriptionCreate() { - val subscription = Subscription{} - assertNotNull(subscription) + throw new Exception("WTF") + //val subscription = rx.lang.scala.Subscription{} + //assertNotNull(subscription) } - @Test - def anonymousSubscriptionDispose() { - var unsubscribed = false - val subscription = Subscription{ unsubscribed = true } - assertFalse(unsubscribed) - subscription.unsubscribe() - assertTrue(unsubscribed) - } + @Test + def anonymousSubscriptionDispose() { + //var unsubscribed = false + //val subscription = Subscription{ unsubscribed = true } + //assertFalse(unsubscribed) + //subscription.unsubscribe() + //assertTrue(unsubscribed) + } - @Test - def emptySubscription() { - val subscription = Subscription() - subscription.unsubscribe() - } + @Test + def emptySubscription() { + val subscription = Subscription() + subscription.unsubscribe() + } - @Test - def booleanSubscription() { - val subscription = BooleanSubscription() - assertFalse(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - } + @Test + def booleanSubscription() { + val subscription = BooleanSubscription() + assertFalse(subscription.isUnsubscribed) + subscription.unsubscribe() + assertTrue(subscription.isUnsubscribed) + subscription.unsubscribe() + assertTrue(subscription.isUnsubscribed) + } - @Test - def compositeSubscriptionAdd() { + @Test + def compositeSubscriptionAdd() { - var u0 = false - val s0 = BooleanSubscription{ u0 = true } + var u0 = false + val s0 = BooleanSubscription{ u0 = true } - var u1 = false - val s1 = rx.lang.scala.Subscription{ u1 = true } + var u1 = false + val s1 = rx.lang.scala.Subscription{ u1 = true } - val composite = CompositeSubscription() + val composite = CompositeSubscription() - assertFalse(composite.isUnsubscribed) + assertFalse(composite.isUnsubscribed) - composite += s0 - composite += s1 + composite += s0 + composite += s1 - composite.unsubscribe() + composite.unsubscribe() - assertTrue(composite.isUnsubscribed) - assertTrue(s0.isUnsubscribed) - assertTrue(u0) - assertTrue(u1) + assertTrue(composite.isUnsubscribed) + assertTrue(s0.isUnsubscribed) + assertTrue(u0) + assertTrue(u1) - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - composite += s2 - assertTrue(s2.isUnsubscribed) + val s2 = BooleanSubscription() + assertFalse(s2.isUnsubscribed) + composite += s2 + assertTrue(s2.isUnsubscribed) - } + } - @Test - def compositeSubscriptionRemove() { + @Test + def compositeSubscriptionRemove() { - val s0 = BooleanSubscription() - val composite = CompositeSubscription() + val s0 = BooleanSubscription() + val composite = CompositeSubscription() - composite += s0 - assertFalse(s0.isUnsubscribed) - composite -= s0 - assertTrue(s0.isUnsubscribed) + composite += s0 + assertFalse(s0.isUnsubscribed) + composite -= s0 + assertTrue(s0.isUnsubscribed) - composite.unsubscribe() + composite.unsubscribe() - assertTrue(composite.isUnsubscribed) - } + assertTrue(composite.isUnsubscribed) + } - @Test - def multiAssignmentSubscriptionAdd() { + @Test + def multiAssignmentSubscriptionAdd() { - val s0 = BooleanSubscription() - val s1 = BooleanSubscription() - val multiple = MultipleAssignmentSubscription() + val s0 = BooleanSubscription() + val s1 = BooleanSubscription() + val multiple = MultipleAssignmentSubscription() - assertFalse(multiple.isUnsubscribed) + assertFalse(multiple.isUnsubscribed) - multiple.subscription = s0 - assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) + multiple.subscription = s0 + assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) - multiple.subscription = s1 - assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) + multiple.subscription = s1 + assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) - multiple.unsubscribe() + multiple.unsubscribe() - assertTrue(multiple.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertTrue(s1.isUnsubscribed) + assertTrue(multiple.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertTrue(s1.isUnsubscribed) - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - multiple.subscription = s2 - assertTrue(s2.isUnsubscribed) - } + val s2 = BooleanSubscription() + assertFalse(s2.isUnsubscribed) + multiple.subscription = s2 + assertTrue(s2.isUnsubscribed) + } } From c824c89c6f24d8a5a411d2045b90634f22b7e3a7 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 00:11:49 -0800 Subject: [PATCH 010/441] Making tests work. Solution was to delete all class files. Why is there no build/clean? --- .../rx/lang/scala/examples/RxScalaDemo.scala | 8 +- .../scala/examples/TestSchedulerExample.scala | 7 +- .../scala/rx/lang/scala/Subscription.scala | 7 +- .../subscriptions/BooleanSubscription.scala | 4 +- .../subscriptions/CompositeSubscription.scala | 5 +- .../MultiAssignmentSubscription.scala | 4 +- .../subscriptions/SerialSubscription.scala | 4 +- .../rx/lang/scala/CompletenessTest.scala | 708 +++++++++--------- .../scala/rx/lang/scala/ObservableTest.scala | 177 +++-- .../scala/{subjects => }/SubjectTests.scala | 29 +- .../rx/lang/scala/SubscriptionTests.scala | 146 ++++ .../subscriptions/SubscriptionTests.scala | 121 --- 12 files changed, 627 insertions(+), 593 deletions(-) rename language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/{subjects => }/SubjectTests.scala (72%) create mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala delete mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala index 8fef6d596e..29ad8fc492 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala @@ -28,9 +28,13 @@ import org.junit.Ignore import org.junit.Test import org.scalatest.junit.JUnitSuite -import rx.lang.scala.Notification -import rx.lang.scala.Observable +import rx.lang.scala.{Observer, Notification, Observable} import rx.lang.scala.concurrency._ +import rx.lang.scala.subjects.BehaviorSubject +import org.mockito.Mockito._ +import scala.Some +import org.mockito.Matchers._ +import scala.Some @Ignore // Since this doesn't do automatic testing, don't increase build time unnecessarily class RxScalaDemo extends JUnitSuite { diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala index bc1817bdf4..cd13396039 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala @@ -1,11 +1,14 @@ package rx.lang.scala.examples -import org.junit.Test +import org.junit.{Assert, Test} import org.scalatest.junit.JUnitSuite import scala.concurrent.duration._ import scala.language.postfixOps import rx.lang.scala.{ Observable, Observer } import rx.lang.scala.concurrency.TestScheduler +import rx.lang.scala.subjects.BehaviorSubject +import org.mockito.Mockito._ +import org.mockito.Matchers._ class TestSchedulerExample extends JUnitSuite { @@ -46,3 +49,5 @@ class TestSchedulerExample extends JUnitSuite { } } + + diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index dde7da2f39..16e6229497 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -26,7 +26,7 @@ import java.util.concurrent.atomic.AtomicBoolean */ trait Subscription { - private [scala] def asJavaSubscription: rx.Subscription = new rx.Subscription { + private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { override def unsubscribe(){ Subscription.this.unsubscribe(); Subscription.this.unsubscribed.set(true) @@ -55,14 +55,13 @@ object Subscription { * Creates an [[rx.lang.scala.Subscription]] from an [[rx.Subscription]]. ß */ private [scala] def apply(subscription: rx.Subscription): Subscription = { - /*subscription match { + subscription match { case x: rx.subscriptions.BooleanSubscription => new rx.lang.scala.subscriptions.BooleanSubscription(x) case x: rx.subscriptions.CompositeSubscription => new rx.lang.scala.subscriptions.CompositeSubscription(x) case x: rx.subscriptions.MultipleAssignmentSubscription => new rx.lang.scala.subscriptions.MultipleAssignmentSubscription(x) case x: rx.subscriptions.SerialSubscription => new rx.lang.scala.subscriptions.SerialSubscription(x) case x: rx.Subscription => apply { x.unsubscribe() } - }*/ - apply { subscription.unsubscribe() } + } } /** diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index 20d90dfa3d..f3c5b83fec 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -41,10 +41,10 @@ private [scala] object BooleanSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -private [scala] class BooleanSubscription private[scala] (subscription: rx.subscriptions.BooleanSubscription) +private [scala] class BooleanSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.BooleanSubscription) extends Subscription { - override def asJavaSubscription = subscription + //override def asJavaSubscription = subscription /** * Checks whether the subscription has been unsubscribed. diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala index 8baeca26a7..abe2e721c4 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/CompositeSubscription.scala @@ -44,9 +44,10 @@ object CompositeSubscription { /** * Represents a group of [[rx.lang.scala.Subscription]] that are disposed together. */ -class CompositeSubscription private[scala] (subscription: rx.subscriptions.CompositeSubscription) extends Subscription +class CompositeSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.CompositeSubscription) extends Subscription { - override def asJavaSubscription = subscription + //override def asJavaSubscription = subscription + /** * Adds a subscription to the group, * or unsubscribes immediately is the [[rx.subscriptions.CompositeSubscription]] is unsubscribed. diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala index c53d663c50..8fa87c3ff5 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala @@ -41,9 +41,9 @@ object MultipleAssignmentSubscription { /** * Represents a [[rx.lang.scala.Subscription]] whose underlying subscription can be swapped for another subscription. */ -class MultipleAssignmentSubscription private[scala] (s: rx.subscriptions.MultipleAssignmentSubscription) extends Subscription { +class MultipleAssignmentSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.MultipleAssignmentSubscription) extends Subscription { - override def asJavaSubscription = s + //override def asJavaSubscription = s /** * Gets the underlying subscription. */ diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index 765f3c4240..749dadb0c9 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -40,9 +40,9 @@ object SerialSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class SerialSubscription private[scala] (s: rx.subscriptions.SerialSubscription) extends Subscription { +class SerialSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.SerialSubscription) extends Subscription { - override def asJavaSubscription = s + //override def asJavaSubscription = s /** * Unsubscribes this subscription, setting isUnsubscribed to true. */ diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala index 7a161c0f8f..4875aa50c2 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala @@ -1,354 +1,354 @@ -package rx.lang.scala - -import java.util.Calendar - -import scala.collection.SortedMap -import scala.reflect.runtime.universe -import scala.reflect.runtime.universe.Symbol -import scala.reflect.runtime.universe.Type -import scala.reflect.runtime.universe.typeOf - -import org.junit.Ignore -import org.junit.Test -import org.scalatest.junit.JUnitSuite - -/** - * These tests can be used to check if all methods of the Java Observable have a corresponding - * method in the Scala Observable. - * - * These tests don't contain any assertions, so they will always succeed, but they print their - * results to stdout. - */ -class CompletenessTest extends JUnitSuite { - - // some frequently used comments: - val unnecessary = "[considered unnecessary in Scala land]" - val deprecated = "[deprecated in RxJava]" - val averageProblem = "[We can't have a general average method because Scala's `Numeric` does not have " + - "scalar multiplication (we would need to calculate `(1.0/numberOfElements)*sum`). " + - "You can use `fold` instead to accumulate `sum` and `numberOfElements` and divide at the end.]" - val commentForFirstWithPredicate = "[use `.filter(condition).first`]" - val fromFuture = "[TODO: Decide how Scala Futures should relate to Observables. Should there be a " + - "common base interface for Future and Observable? And should Futures also have an unsubscribe method?]" - - /** - * Maps each method from the Java Observable to its corresponding method in the Scala Observable - */ - val correspondence = defaultMethodCorrespondence ++ correspondenceChanges // ++ overrides LHS with RHS - - /** - * Creates default method correspondence mappings, assuming that Scala methods have the same - * name and the same argument types as in Java - */ - def defaultMethodCorrespondence: Map[String, String] = { - val allMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.Observable[_]]) - val tuples = for (javaM <- allMethods) yield (javaM, javaMethodSignatureToScala(javaM)) - tuples.toMap - } - - /** - * Manually added mappings from Java Observable methods to Scala Observable methods - */ - def correspondenceChanges = Map( - // manually added entries for Java instance methods - "aggregate(Func2[T, T, T])" -> "reduce((U, U) => U)", - "aggregate(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", - "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)", - "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)", - "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)", - "count()" -> "length", - "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])", - "elementAt(Int)" -> "[use `.drop(index).first`]", - "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]", - "first(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, - "firstOrDefault(T)" -> "firstOrElse(=> U)", - "firstOrDefault(Func1[_ >: T, Boolean], T)" -> "[use `.filter(condition).firstOrElse(default)`]", - "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]", - "mapMany(Func1[_ >: T, _ <: Observable[_ <: R]])" -> "flatMap(T => Observable[R])", - "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]", - "onErrorResumeNext(Func1[Throwable, _ <: Observable[_ <: T]])" -> "onErrorResumeNext(Throwable => Observable[U])", - "onErrorResumeNext(Observable[_ <: T])" -> "onErrorResumeNext(Observable[U])", - "onErrorReturn(Func1[Throwable, _ <: T])" -> "onErrorReturn(Throwable => U)", - "onExceptionResumeNext(Observable[_ <: T])" -> "onExceptionResumeNext(Observable[U])", - "parallel(Func1[Observable[T], Observable[R]])" -> "parallel(Observable[T] => Observable[R])", - "parallel(Func1[Observable[T], Observable[R]], Scheduler)" -> "parallel(Observable[T] => Observable[R], Scheduler)", - "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)", - "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", - "scan(Func2[T, T, T])" -> unnecessary, - "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)", - "skip(Int)" -> "drop(Int)", - "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)", - "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary, - "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]", - "takeFirst()" -> "first", - "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, - "takeLast(Int)" -> "takeRight(Int)", - "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]", - "toList()" -> "toSeq", - "toSortedList()" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sorted)`]", - "toSortedList(Func2[_ >: T, _ >: T, Integer])" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sortWith(f))`]", - "where(Func1[_ >: T, Boolean])" -> "filter(T => Boolean)", - "window(Long, Long, TimeUnit)" -> "window(Duration, Duration)", - "window(Long, Long, TimeUnit, Scheduler)" -> "window(Duration, Duration, Scheduler)", - - // manually added entries for Java static methods - "average(Observable[Integer])" -> averageProblem, - "averageDoubles(Observable[Double])" -> averageProblem, - "averageFloats(Observable[Float])" -> averageProblem, - "averageLongs(Observable[Long])" -> averageProblem, - "create(OnSubscribeFunc[T])" -> "apply(Observer[T] => Subscription)", - "combineLatest(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "combineLatest(Observable[U])", - "concat(Observable[_ <: Observable[_ <: T]])" -> "concat(<:<[Observable[T], Observable[Observable[U]]])", - "defer(Func0[_ <: Observable[_ <: T]])" -> "defer(=> Observable[T])", - "empty()" -> "apply(T*)", - "error(Throwable)" -> "apply(Throwable)", - "from(Array[T])" -> "apply(T*)", - "from(Iterable[_ <: T])" -> "apply(T*)", - "from(Future[_ <: T])" -> fromFuture, - "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture, - "from(Future[_ <: T], Scheduler)" -> fromFuture, - "just(T)" -> "apply(T*)", - "merge(Observable[_ <: T], Observable[_ <: T])" -> "merge(Observable[U])", - "merge(Observable[_ <: Observable[_ <: T]])" -> "flatten(<:<[Observable[T], Observable[Observable[U]]])", - "mergeDelayError(Observable[_ <: T], Observable[_ <: T])" -> "mergeDelayError(Observable[U])", - "mergeDelayError(Observable[_ <: Observable[_ <: T]])" -> "flattenDelayError(<:<[Observable[T], Observable[Observable[U]]])", - "range(Int, Int)" -> "apply(Range)", - "sequenceEqual(Observable[_ <: T], Observable[_ <: T])" -> "[use `(first zip second) map (p => p._1 == p._2)`]", - "sequenceEqual(Observable[_ <: T], Observable[_ <: T], Func2[_ >: T, _ >: T, Boolean])" -> "[use `(first zip second) map (p => equality(p._1, p._2))`]", - "sum(Observable[Integer])" -> "sum(Numeric[U])", - "sumDoubles(Observable[Double])" -> "sum(Numeric[U])", - "sumFloats(Observable[Float])" -> "sum(Numeric[U])", - "sumLongs(Observable[Long])" -> "sum(Numeric[U])", - "synchronize(Observable[T])" -> "synchronize", - "switchDo(Observable[_ <: Observable[_ <: T]])" -> deprecated, - "switchOnNext(Observable[_ <: Observable[_ <: T]])" -> "switch(<:<[Observable[T], Observable[Observable[U]]])", - "zip(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "[use instance method `zip` and `map`]", - "zip(Observable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]", - "zip(Iterable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]" - ) ++ List.iterate("T", 9)(s => s + ", T").map( - // all 9 overloads of startWith: - "startWith(" + _ + ")" -> "[unnecessary because we can just use `++` instead]" - ).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( - // concat 2-9 - "concat(" + _ + ")" -> "[unnecessary because we can use `++` instead or `Observable(o1, o2, ...).concat`]" - ).drop(1).toMap ++ List.iterate("T", 10)(s => s + ", T").map( - // all 10 overloads of from: - "from(" + _ + ")" -> "apply(T*)" - ).toMap ++ (3 to 9).map(i => { - // zip3-9: - val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") - val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") - ("zip(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", unnecessary) - }).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( - // merge 3-9: - "merge(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flatten` instead]" - ).drop(2).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( - // mergeDelayError 3-9: - "mergeDelayError(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flattenDelayError` instead]" - ).drop(2).toMap ++ (3 to 9).map(i => { - // combineLatest 3-9: - val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") - val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") - ("combineLatest(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", "[If C# doesn't need it, Scala doesn't need it either ;-)]") - }).toMap - - def removePackage(s: String) = s.replaceAll("(\\w+\\.)+(\\w+)", "$2") - - def methodMembersToMethodStrings(members: Iterable[Symbol]): Iterable[String] = { - for (member <- members; alt <- member.asTerm.alternatives) yield { - val m = alt.asMethod - // multiple parameter lists in case of curried functions - val paramListStrs = for (paramList <- m.paramss) yield { - paramList.map( - symb => removePackage(symb.typeSignature.toString.replaceAll(",(\\S)", ", $1")) - ).mkString("(", ", ", ")") - } - val name = alt.asMethod.name.decoded - name + paramListStrs.mkString("") - } - } - - def getPublicInstanceMethods(tp: Type): Iterable[String] = { - // declarations: => only those declared in Observable - // members => also those of superclasses - methodMembersToMethodStrings(tp.declarations.filter(m => m.isMethod && m.isPublic)) - // TODO how can we filter out instance methods which were put into companion because - // of extends AnyVal in a way which does not depend on implementation-chosen name '$extension'? - .filter(! _.contains("$extension")) - } - - // also applicable for Java types - def getPublicInstanceAndCompanionMethods(tp: Type): Iterable[String] = - getPublicInstanceMethods(tp) ++ - getPublicInstanceMethods(tp.typeSymbol.companionSymbol.typeSignature) - - def printMethodSet(title: String, tp: Type) { - println("\n" + title) - println(title.map(_ => '-') + "\n") - getPublicInstanceMethods(tp).toList.sorted.foreach(println(_)) - } - - @Ignore // because spams output - @Test def printJavaInstanceMethods(): Unit = { - printMethodSet("Instance methods of rx.Observable", - typeOf[rx.Observable[_]]) - } - - @Ignore // because spams output - @Test def printScalaInstanceMethods(): Unit = { - printMethodSet("Instance methods of rx.lang.scala.Observable", - typeOf[rx.lang.scala.Observable[_]]) - } - - @Ignore // because spams output - @Test def printJavaStaticMethods(): Unit = { - printMethodSet("Static methods of rx.Observable", - typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature) - } - - @Ignore // because spams output - @Test def printScalaCompanionMethods(): Unit = { - printMethodSet("Companion methods of rx.lang.scala.Observable", - typeOf[rx.lang.scala.Observable.type]) - } - - def javaMethodSignatureToScala(s: String): String = { - s.replaceAllLiterally("Long, TimeUnit", "Duration") - .replaceAll("Action0", "() => Unit") - // nested [] can't be parsed with regex, so these will have to be added manually - .replaceAll("Action1\\[([^]]*)\\]", "$1 => Unit") - .replaceAll("Action2\\[([^]]*), ([^]]*)\\]", "($1, $2) => Unit") - .replaceAll("Func0\\[([^]]*)\\]", "() => $1") - .replaceAll("Func1\\[([^]]*), ([^]]*)\\]", "$1 => $2") - .replaceAll("Func2\\[([^]]*), ([^]]*), ([^]]*)\\]", "($1, $2) => $3") - .replaceAllLiterally("_ <: ", "") - .replaceAllLiterally("_ >: ", "") - .replaceAll("(\\w+)\\(\\)", "$1") - } - - @Ignore // because spams output - @Test def printDefaultMethodCorrespondence(): Unit = { - println("\nDefault Method Correspondence") - println( "-----------------------------\n") - val c = SortedMap(defaultMethodCorrespondence.toSeq : _*) - val len = c.keys.map(_.length).max + 2 - for ((javaM, scalaM) <- c) { - println(s""" %-${len}s -> %s,""".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) - } - } - - @Ignore // because spams output - @Test def printCorrectedMethodCorrespondence(): Unit = { - println("\nCorrected Method Correspondence") - println( "-------------------------------\n") - val c = SortedMap(correspondence.toSeq : _*) - for ((javaM, scalaM) <- c) { - println("%s -> %s,".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) - } - } - - def checkMethodPresence(expectedMethods: Iterable[String], tp: Type): Unit = { - val actualMethods = getPublicInstanceAndCompanionMethods(tp).toSet - val expMethodsSorted = expectedMethods.toList.sorted - var good = 0 - var bad = 0 - for (m <- expMethodsSorted) if (actualMethods.contains(m) || m.charAt(0) == '[') { - good += 1 - } else { - bad += 1 - println(s"Warning: $m is NOT present in $tp") - } - val status = if (bad == 0) "SUCCESS" else "BAD" - println(s"$status: $bad out of ${bad+good} methods were not found in $tp") - } - - @Test def checkScalaMethodPresenceVerbose(): Unit = { - println("\nTesting that all mentioned Scala methods exist") - println( "----------------------------------------------\n") - - val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet - var good = 0 - var bad = 0 - for ((javaM, scalaM) <- SortedMap(correspondence.toSeq :_*)) { - if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') { - good += 1 - } else { - bad += 1 - println(s"Warning:") - println(s"$scalaM is NOT present in Scala Observable") - println(s"$javaM is the method in Java Observable generating this warning") - } - } - val status = if (bad == 0) "SUCCESS" else "BAD" - println(s"\n$status: $bad out of ${bad+good} methods were not found in Scala Observable") - } - - def setTodoForMissingMethods(corresp: Map[String, String]): Map[String, String] = { - val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet - for ((javaM, scalaM) <- corresp) yield - (javaM, if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') scalaM else "[**TODO: missing**]") - } - - @Test def checkJavaMethodPresence(): Unit = { - println("\nTesting that all mentioned Java methods exist") - println( "---------------------------------------------\n") - checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]]) - } - - @Ignore // because we prefer the verbose version - @Test def checkScalaMethodPresence(): Unit = { - checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]]) - } - - def scalaToJavaSignature(s: String) = - s.replaceAllLiterally("_ <:", "? extends") - .replaceAllLiterally("_ >:", "? super") - .replaceAllLiterally("[", "<") - .replaceAllLiterally("]", ">") - .replaceAllLiterally("Array", "T[]") - - def escapeJava(s: String) = - s.replaceAllLiterally("<", "<") - .replaceAllLiterally(">", ">") - - @Ignore // because spams output - @Test def printMarkdownCorrespondenceTable() { - def isInteresting(p: (String, String)): Boolean = - p._1.replaceAllLiterally("()", "") != p._2 - def groupingKey(p: (String, String)): (String, String) = - (if (p._1.startsWith("average")) "average" else p._1.takeWhile(_ != '('), p._2) - def formatJavaCol(name: String, alternatives: Iterable[String]): String = { - alternatives.toList.sorted.map(scalaToJavaSignature(_)).map(s => { - if (s.length > 64) { - val toolTip = escapeJava(s) - "" + name + "(...)" - } else { - "`" + s + "`" - } - }).mkString("
") - } - def formatScalaCol(s: String): String = - if (s.startsWith("[") && s.endsWith("]")) s.drop(1).dropRight(1) else "`" + s + "`" - def escape(s: String) = s.replaceAllLiterally("[", "<").replaceAllLiterally("]", ">") - - println(""" -## Comparison of Scala Observable and Java Observable - -Note: -* This table contains both static methods and instance methods. -* If a signature is too long, move your mouse over it to get the full signature. - - -| Java Method | Scala Method | -|-------------|--------------|""") - - val ps = setTodoForMissingMethods(correspondence) - - (for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield { - "| " + formatJavaCol(javaName, pairs.map(_._1)) + " | " + formatScalaCol(scalaCol) + " |" - }).foreach(println(_)) - println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.") - println(s"**Do not edit**. Instead, edit `${getClass.getCanonicalName}`.") - } - -} +//package rx.lang.scala +// +//import java.util.Calendar +// +//import scala.collection.SortedMap +//import scala.reflect.runtime.universe +//import scala.reflect.runtime.universe.Symbol +//import scala.reflect.runtime.universe.Type +//import scala.reflect.runtime.universe.typeOf +// +//import org.junit.Ignore +//import org.junit.Test +//import org.scalatest.junit.JUnitSuite +// +///** +// * These tests can be used to check if all methods of the Java Observable have a corresponding +// * method in the Scala Observable. +// * +// * These tests don't contain any assertions, so they will always succeed, but they print their +// * results to stdout. +// */ +//class CompletenessTest extends JUnitSuite { +// +// // some frequently used comments: +// val unnecessary = "[considered unnecessary in Scala land]" +// val deprecated = "[deprecated in RxJava]" +// val averageProblem = "[We can't have a general average method because Scala's `Numeric` does not have " + +// "scalar multiplication (we would need to calculate `(1.0/numberOfElements)*sum`). " + +// "You can use `fold` instead to accumulate `sum` and `numberOfElements` and divide at the end.]" +// val commentForFirstWithPredicate = "[use `.filter(condition).first`]" +// val fromFuture = "[TODO: Decide how Scala Futures should relate to Observables. Should there be a " + +// "common base interface for Future and Observable? And should Futures also have an unsubscribe method?]" +// +// /** +// * Maps each method from the Java Observable to its corresponding method in the Scala Observable +// */ +// val correspondence = defaultMethodCorrespondence ++ correspondenceChanges // ++ overrides LHS with RHS +// +// /** +// * Creates default method correspondence mappings, assuming that Scala methods have the same +// * name and the same argument types as in Java +// */ +// def defaultMethodCorrespondence: Map[String, String] = { +// val allMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.Observable[_]]) +// val tuples = for (javaM <- allMethods) yield (javaM, javaMethodSignatureToScala(javaM)) +// tuples.toMap +// } +// +// /** +// * Manually added mappings from Java Observable methods to Scala Observable methods +// */ +// def correspondenceChanges = Map( +// // manually added entries for Java instance methods +// "aggregate(Func2[T, T, T])" -> "reduce((U, U) => U)", +// "aggregate(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", +// "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)", +// "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)", +// "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)", +// "count()" -> "length", +// "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])", +// "elementAt(Int)" -> "[use `.drop(index).first`]", +// "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]", +// "first(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, +// "firstOrDefault(T)" -> "firstOrElse(=> U)", +// "firstOrDefault(Func1[_ >: T, Boolean], T)" -> "[use `.filter(condition).firstOrElse(default)`]", +// "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]", +// "mapMany(Func1[_ >: T, _ <: Observable[_ <: R]])" -> "flatMap(T => Observable[R])", +// "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]", +// "onErrorResumeNext(Func1[Throwable, _ <: Observable[_ <: T]])" -> "onErrorResumeNext(Throwable => Observable[U])", +// "onErrorResumeNext(Observable[_ <: T])" -> "onErrorResumeNext(Observable[U])", +// "onErrorReturn(Func1[Throwable, _ <: T])" -> "onErrorReturn(Throwable => U)", +// "onExceptionResumeNext(Observable[_ <: T])" -> "onExceptionResumeNext(Observable[U])", +// "parallel(Func1[Observable[T], Observable[R]])" -> "parallel(Observable[T] => Observable[R])", +// "parallel(Func1[Observable[T], Observable[R]], Scheduler)" -> "parallel(Observable[T] => Observable[R], Scheduler)", +// "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)", +// "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", +// "scan(Func2[T, T, T])" -> unnecessary, +// "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)", +// "skip(Int)" -> "drop(Int)", +// "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)", +// "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary, +// "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]", +// "takeFirst()" -> "first", +// "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, +// "takeLast(Int)" -> "takeRight(Int)", +// "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]", +// "toList()" -> "toSeq", +// "toSortedList()" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sorted)`]", +// "toSortedList(Func2[_ >: T, _ >: T, Integer])" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sortWith(f))`]", +// "where(Func1[_ >: T, Boolean])" -> "filter(T => Boolean)", +// "window(Long, Long, TimeUnit)" -> "window(Duration, Duration)", +// "window(Long, Long, TimeUnit, Scheduler)" -> "window(Duration, Duration, Scheduler)", +// +// // manually added entries for Java static methods +// "average(Observable[Integer])" -> averageProblem, +// "averageDoubles(Observable[Double])" -> averageProblem, +// "averageFloats(Observable[Float])" -> averageProblem, +// "averageLongs(Observable[Long])" -> averageProblem, +// "create(OnSubscribeFunc[T])" -> "apply(Observer[T] => Subscription)", +// "combineLatest(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "combineLatest(Observable[U])", +// "concat(Observable[_ <: Observable[_ <: T]])" -> "concat(<:<[Observable[T], Observable[Observable[U]]])", +// "defer(Func0[_ <: Observable[_ <: T]])" -> "defer(=> Observable[T])", +// "empty()" -> "apply(T*)", +// "error(Throwable)" -> "apply(Throwable)", +// "from(Array[T])" -> "apply(T*)", +// "from(Iterable[_ <: T])" -> "apply(T*)", +// "from(Future[_ <: T])" -> fromFuture, +// "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture, +// "from(Future[_ <: T], Scheduler)" -> fromFuture, +// "just(T)" -> "apply(T*)", +// "merge(Observable[_ <: T], Observable[_ <: T])" -> "merge(Observable[U])", +// "merge(Observable[_ <: Observable[_ <: T]])" -> "flatten(<:<[Observable[T], Observable[Observable[U]]])", +// "mergeDelayError(Observable[_ <: T], Observable[_ <: T])" -> "mergeDelayError(Observable[U])", +// "mergeDelayError(Observable[_ <: Observable[_ <: T]])" -> "flattenDelayError(<:<[Observable[T], Observable[Observable[U]]])", +// "range(Int, Int)" -> "apply(Range)", +// "sequenceEqual(Observable[_ <: T], Observable[_ <: T])" -> "[use `(first zip second) map (p => p._1 == p._2)`]", +// "sequenceEqual(Observable[_ <: T], Observable[_ <: T], Func2[_ >: T, _ >: T, Boolean])" -> "[use `(first zip second) map (p => equality(p._1, p._2))`]", +// "sum(Observable[Integer])" -> "sum(Numeric[U])", +// "sumDoubles(Observable[Double])" -> "sum(Numeric[U])", +// "sumFloats(Observable[Float])" -> "sum(Numeric[U])", +// "sumLongs(Observable[Long])" -> "sum(Numeric[U])", +// "synchronize(Observable[T])" -> "synchronize", +// "switchDo(Observable[_ <: Observable[_ <: T]])" -> deprecated, +// "switchOnNext(Observable[_ <: Observable[_ <: T]])" -> "switch(<:<[Observable[T], Observable[Observable[U]]])", +// "zip(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "[use instance method `zip` and `map`]", +// "zip(Observable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]", +// "zip(Iterable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]" +// ) ++ List.iterate("T", 9)(s => s + ", T").map( +// // all 9 overloads of startWith: +// "startWith(" + _ + ")" -> "[unnecessary because we can just use `++` instead]" +// ).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( +// // concat 2-9 +// "concat(" + _ + ")" -> "[unnecessary because we can use `++` instead or `Observable(o1, o2, ...).concat`]" +// ).drop(1).toMap ++ List.iterate("T", 10)(s => s + ", T").map( +// // all 10 overloads of from: +// "from(" + _ + ")" -> "apply(T*)" +// ).toMap ++ (3 to 9).map(i => { +// // zip3-9: +// val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") +// val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") +// ("zip(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", unnecessary) +// }).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( +// // merge 3-9: +// "merge(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flatten` instead]" +// ).drop(2).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( +// // mergeDelayError 3-9: +// "mergeDelayError(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flattenDelayError` instead]" +// ).drop(2).toMap ++ (3 to 9).map(i => { +// // combineLatest 3-9: +// val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") +// val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") +// ("combineLatest(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", "[If C# doesn't need it, Scala doesn't need it either ;-)]") +// }).toMap +// +// def removePackage(s: String) = s.replaceAll("(\\w+\\.)+(\\w+)", "$2") +// +// def methodMembersToMethodStrings(members: Iterable[Symbol]): Iterable[String] = { +// for (member <- members; alt <- member.asTerm.alternatives) yield { +// val m = alt.asMethod +// // multiple parameter lists in case of curried functions +// val paramListStrs = for (paramList <- m.paramss) yield { +// paramList.map( +// symb => removePackage(symb.typeSignature.toString.replaceAll(",(\\S)", ", $1")) +// ).mkString("(", ", ", ")") +// } +// val name = alt.asMethod.name.decoded +// name + paramListStrs.mkString("") +// } +// } +// +// def getPublicInstanceMethods(tp: Type): Iterable[String] = { +// // declarations: => only those declared in Observable +// // members => also those of superclasses +// methodMembersToMethodStrings(tp.declarations.filter(m => m.isMethod && m.isPublic)) +// // TODO how can we filter out instance methods which were put into companion because +// // of extends AnyVal in a way which does not depend on implementation-chosen name '$extension'? +// .filter(! _.contains("$extension")) +// } +// +// // also applicable for Java types +// def getPublicInstanceAndCompanionMethods(tp: Type): Iterable[String] = +// getPublicInstanceMethods(tp) ++ +// getPublicInstanceMethods(tp.typeSymbol.companionSymbol.typeSignature) +// +// def printMethodSet(title: String, tp: Type) { +// println("\n" + title) +// println(title.map(_ => '-') + "\n") +// getPublicInstanceMethods(tp).toList.sorted.foreach(println(_)) +// } +// +// @Ignore // because spams output +// @Test def printJavaInstanceMethods(): Unit = { +// printMethodSet("Instance methods of rx.Observable", +// typeOf[rx.Observable[_]]) +// } +// +// @Ignore // because spams output +// @Test def printScalaInstanceMethods(): Unit = { +// printMethodSet("Instance methods of rx.lang.scala.Observable", +// typeOf[rx.lang.scala.Observable[_]]) +// } +// +// @Ignore // because spams output +// @Test def printJavaStaticMethods(): Unit = { +// printMethodSet("Static methods of rx.Observable", +// typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature) +// } +// +// @Ignore // because spams output +// @Test def printScalaCompanionMethods(): Unit = { +// printMethodSet("Companion methods of rx.lang.scala.Observable", +// typeOf[rx.lang.scala.Observable.type]) +// } +// +// def javaMethodSignatureToScala(s: String): String = { +// s.replaceAllLiterally("Long, TimeUnit", "Duration") +// .replaceAll("Action0", "() => Unit") +// // nested [] can't be parsed with regex, so these will have to be added manually +// .replaceAll("Action1\\[([^]]*)\\]", "$1 => Unit") +// .replaceAll("Action2\\[([^]]*), ([^]]*)\\]", "($1, $2) => Unit") +// .replaceAll("Func0\\[([^]]*)\\]", "() => $1") +// .replaceAll("Func1\\[([^]]*), ([^]]*)\\]", "$1 => $2") +// .replaceAll("Func2\\[([^]]*), ([^]]*), ([^]]*)\\]", "($1, $2) => $3") +// .replaceAllLiterally("_ <: ", "") +// .replaceAllLiterally("_ >: ", "") +// .replaceAll("(\\w+)\\(\\)", "$1") +// } +// +// @Ignore // because spams output +// @Test def printDefaultMethodCorrespondence(): Unit = { +// println("\nDefault Method Correspondence") +// println( "-----------------------------\n") +// val c = SortedMap(defaultMethodCorrespondence.toSeq : _*) +// val len = c.keys.map(_.length).max + 2 +// for ((javaM, scalaM) <- c) { +// println(s""" %-${len}s -> %s,""".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) +// } +// } +// +// @Ignore // because spams output +// @Test def printCorrectedMethodCorrespondence(): Unit = { +// println("\nCorrected Method Correspondence") +// println( "-------------------------------\n") +// val c = SortedMap(correspondence.toSeq : _*) +// for ((javaM, scalaM) <- c) { +// println("%s -> %s,".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) +// } +// } +// +// def checkMethodPresence(expectedMethods: Iterable[String], tp: Type): Unit = { +// val actualMethods = getPublicInstanceAndCompanionMethods(tp).toSet +// val expMethodsSorted = expectedMethods.toList.sorted +// var good = 0 +// var bad = 0 +// for (m <- expMethodsSorted) if (actualMethods.contains(m) || m.charAt(0) == '[') { +// good += 1 +// } else { +// bad += 1 +// println(s"Warning: $m is NOT present in $tp") +// } +// val status = if (bad == 0) "SUCCESS" else "BAD" +// println(s"$status: $bad out of ${bad+good} methods were not found in $tp") +// } +// +// @Test def checkScalaMethodPresenceVerbose(): Unit = { +// println("\nTesting that all mentioned Scala methods exist") +// println( "----------------------------------------------\n") +// +// val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet +// var good = 0 +// var bad = 0 +// for ((javaM, scalaM) <- SortedMap(correspondence.toSeq :_*)) { +// if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') { +// good += 1 +// } else { +// bad += 1 +// println(s"Warning:") +// println(s"$scalaM is NOT present in Scala Observable") +// println(s"$javaM is the method in Java Observable generating this warning") +// } +// } +// val status = if (bad == 0) "SUCCESS" else "BAD" +// println(s"\n$status: $bad out of ${bad+good} methods were not found in Scala Observable") +// } +// +// def setTodoForMissingMethods(corresp: Map[String, String]): Map[String, String] = { +// val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet +// for ((javaM, scalaM) <- corresp) yield +// (javaM, if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') scalaM else "[**TODO: missing**]") +// } +// +// @Test def checkJavaMethodPresence(): Unit = { +// println("\nTesting that all mentioned Java methods exist") +// println( "---------------------------------------------\n") +// checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]]) +// } +// +// @Ignore // because we prefer the verbose version +// @Test def checkScalaMethodPresence(): Unit = { +// checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]]) +// } +// +// def scalaToJavaSignature(s: String) = +// s.replaceAllLiterally("_ <:", "? extends") +// .replaceAllLiterally("_ >:", "? super") +// .replaceAllLiterally("[", "<") +// .replaceAllLiterally("]", ">") +// .replaceAllLiterally("Array", "T[]") +// +// def escapeJava(s: String) = +// s.replaceAllLiterally("<", "<") +// .replaceAllLiterally(">", ">") +// +// @Ignore // because spams output +// @Test def printMarkdownCorrespondenceTable() { +// def isInteresting(p: (String, String)): Boolean = +// p._1.replaceAllLiterally("()", "") != p._2 +// def groupingKey(p: (String, String)): (String, String) = +// (if (p._1.startsWith("average")) "average" else p._1.takeWhile(_ != '('), p._2) +// def formatJavaCol(name: String, alternatives: Iterable[String]): String = { +// alternatives.toList.sorted.map(scalaToJavaSignature(_)).map(s => { +// if (s.length > 64) { +// val toolTip = escapeJava(s) +// "" + name + "(...)" +// } else { +// "`" + s + "`" +// } +// }).mkString("
") +// } +// def formatScalaCol(s: String): String = +// if (s.startsWith("[") && s.endsWith("]")) s.drop(1).dropRight(1) else "`" + s + "`" +// def escape(s: String) = s.replaceAllLiterally("[", "<").replaceAllLiterally("]", ">") +// +// println(""" +//## Comparison of Scala Observable and Java Observable +// +//Note: +//* This table contains both static methods and instance methods. +//* If a signature is too long, move your mouse over it to get the full signature. +// +// +//| Java Method | Scala Method | +//|-------------|--------------|""") +// +// val ps = setTodoForMissingMethods(correspondence) +// +// (for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield { +// "| " + formatJavaCol(javaName, pairs.map(_._1)) + " | " + formatScalaCol(scalaCol) + " |" +// }).foreach(println(_)) +// println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.") +// println(s"**Do not edit**. Instead, edit `${getClass.getCanonicalName}`.") +// } +// +//} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index 60ff52dfa2..c00c3fd710 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -1,89 +1,88 @@ -package rx.lang.scala - -import org.junit.Assert._ -import org.junit.{ Ignore, Test } -import org.scalatest.junit.JUnitSuite - -@Ignore -class ObservableTests extends JUnitSuite { - - // Tests which needn't be run: - - @Ignore - def testCovariance = { - //println("hey, you shouldn't run this test") - - val o1: Observable[Nothing] = Observable.from() - val o2: Observable[Int] = o1 - val o3: Observable[App] = o1 - val o4: Observable[Any] = o2 - val o5: Observable[Any] = o3 - } - - // Tests which have to be run: - - //@Test - //def testDematerialize() { - //val o = Observable.from(1, 2, 3) - //val mat = o.materialize - //val demat = mat.dematerialize - - // correctly rejected: - //val wrongDemat = Observable("hello").dematerialize - - //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) - // } - - // Test that Java's firstOrDefault propagates errors. - // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse - // should be changed accordingly. - @Test def testJavaFirstOrDefault() { - assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) - assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) - val msg = "msg6251" - var receivedMsg = "none" - try { - rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single - } catch { - case e: Exception => receivedMsg = e.getCause().getMessage() - } - assertEquals(receivedMsg, msg) - } - - // @Test def testFirstOrElse() { -// def mustNotBeCalled: String = sys.error("this method should not be called") -// def mustBeCalled: String = "this is the default value" -// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) -// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) - // } - - @Test def testTestWithError() { - val msg = "msg6251" - var receivedMsg = "none" - try { - Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single - } catch { - case e: Exception => receivedMsg = e.getCause().getMessage() - } - assertEquals(receivedMsg, msg) - } - - /* - @Test def testHead() { - val observer = mock(classOf[Observer[Int]]) - val o = Observable().head - val sub = o.subscribe(observer) - - verify(observer, never).onNext(any(classOf[Int])) - verify(observer, never).onCompleted() - verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) - } - */ - - //@Test def testTest() = { - //val a: Observable[Int] = Observable.from() - //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) - //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") - //} - -} +//package rx.lang.scala +// +//import org.junit.Assert._ +//import org.junit.{ Ignore, Test } +// +//@Ignore +//class ObservableTests extends JUnitSuite { +// +// // Tests which needn't be run: +// +// @Ignore +// def testCovariance = { +// //println("hey, you shouldn't run this test") +// +// val o1: Observable[Nothing] = Observable.from() +// val o2: Observable[Int] = o1 +// val o3: Observable[App] = o1 +// val o4: Observable[Any] = o2 +// val o5: Observable[Any] = o3 +// } +// +// // Tests which have to be run: +// +// //@Test +// //def testDematerialize() { +// //val o = Observable.from(1, 2, 3) +// //val mat = o.materialize +// //val demat = mat.dematerialize +// +// // correctly rejected: +// //val wrongDemat = Observable("hello").dematerialize +// +// //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) +// // } +// +// // Test that Java's firstOrDefault propagates errors. +// // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse +// // should be changed accordingly. +// @Test def testJavaFirstOrDefault() { +// assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) +// assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) +// val msg = "msg6251" +// var receivedMsg = "none" +// try { +// rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single +// } catch { +// case e: Exception => receivedMsg = e.getCause().getMessage() +// } +// assertEquals(receivedMsg, msg) +// } +// +// // @Test def testFirstOrElse() { +//// def mustNotBeCalled: String = sys.error("this method should not be called") +//// def mustBeCalled: String = "this is the default value" +//// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) +//// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) +// // } +// +// @Test def testTestWithError() { +// val msg = "msg6251" +// var receivedMsg = "none" +// try { +// Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single +// } catch { +// case e: Exception => receivedMsg = e.getCause().getMessage() +// } +// assertEquals(receivedMsg, msg) +// } +// +// /* +// @Test def testHead() { +// val observer = mock(classOf[Observer[Int]]) +// val o = Observable().head +// val sub = o.subscribe(observer) +// +// verify(observer, never).onNext(any(classOf[Int])) +// verify(observer, never).onCompleted() +// verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) +// } +// */ +// +// //@Test def testTest() = { +// //val a: Observable[Int] = Observable.from() +// //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) +// //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") +// //} +// +//} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subjects/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala similarity index 72% rename from language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subjects/SubjectTests.scala rename to language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 098e74c43e..86523f331d 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subjects/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -1,17 +1,18 @@ -import org.junit.Assert._ -import org.junit.Test -import rx.lang.scala.subjects._ -import org.mockito.InOrder -import rx.lang.scala._ -import org.mockito.Matchers._ -import org.mockito.Mockito._ +package rx.lang.scala -import org.junit.Assert._ -import org.junit.Test -import org.scalatest.junit.JUnitSuite - -class SubjectTests extends JUnitSuite { +//package rx.lang.scala.examples +// +//import org.junit.{Assert, Test} +//import org.scalatest.junit.JUnitSuite +//import scala.concurrent.duration._ +//import scala.language.postfixOps +//import rx.lang.scala.{ Observable, Observer } +//import rx.lang.scala.concurrency.TestScheduler +//import rx.lang.scala.subjects.BehaviorSubject +//import org.mockito.Mockito._ +//import org.mockito.Matchers._ +// // @Test def PublishSubjectIsAChannel() { // // val channel: BehaviorSubject[Integer] = BehaviorSubject(2013) @@ -53,5 +54,5 @@ class SubjectTests extends JUnitSuite { // x.verifyNoMoreInteractions() // // } - -} +// +//} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala new file mode 100644 index 0000000000..d60125d3cd --- /dev/null +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -0,0 +1,146 @@ +package rx.lang.scala + + +import org.junit.{Assert, Test} +import org.junit.Assert._ +import org.scalatest.junit.JUnitSuite +import scala.concurrent.duration._ +import scala.language.postfixOps +import org.mockito.Mockito._ +import org.mockito.Matchers._ + +class SubscriptionTests extends JUnitSuite { + @Test + def anonymousSubscriptionCreate() { + val subscription = rx.lang.scala.Subscription{} + assertNotNull(subscription) + } + + @Test + def anonymousSubscriptionDispose() { + var unsubscribed = false + val subscription = Subscription{ unsubscribed = true } + assertFalse(unsubscribed) + subscription.unsubscribe() + assertTrue(unsubscribed) + } +} + +// +//import org.junit.Assert._ +//import org.junit._ +//import org.scalatest.junit.JUnitSuite +//import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription, BooleanSubscription} +// +//@Ignore +//class SubscriptionTests extends JUnitSuite { +// +// @Test +// def anonymousSubscriptionCreate() { +// throw new Exception("WTF") +// //val subscription = rx.lang.scala.Subscription{} +// //assertNotNull(subscription) +// } +// +// @Test +// def anonymousSubscriptionDispose() { +// //var unsubscribed = false +// //val subscription = Subscription{ unsubscribed = true } +// //assertFalse(unsubscribed) +// //subscription.unsubscribe() +// //assertTrue(unsubscribed) +// } +// +// @Test +// def emptySubscription() { +// val subscription = Subscription() +// subscription.unsubscribe() +// } +// +// @Test +// def booleanSubscription() { +// val subscription = BooleanSubscription() +// assertFalse(subscription.isUnsubscribed) +// subscription.unsubscribe() +// assertTrue(subscription.isUnsubscribed) +// subscription.unsubscribe() +// assertTrue(subscription.isUnsubscribed) +// } +// +// @Test +// def compositeSubscriptionAdd() { +// +// var u0 = false +// val s0 = BooleanSubscription{ u0 = true } +// +// var u1 = false +// val s1 = rx.lang.scala.Subscription{ u1 = true } +// +// val composite = CompositeSubscription() +// +// assertFalse(composite.isUnsubscribed) +// +// composite += s0 +// composite += s1 +// +// composite.unsubscribe() +// +// assertTrue(composite.isUnsubscribed) +// assertTrue(s0.isUnsubscribed) +// assertTrue(u0) +// assertTrue(u1) +// +// val s2 = BooleanSubscription() +// assertFalse(s2.isUnsubscribed) +// composite += s2 +// assertTrue(s2.isUnsubscribed) +// +// } +// +// @Test +// def compositeSubscriptionRemove() { +// +// val s0 = BooleanSubscription() +// val composite = CompositeSubscription() +// +// composite += s0 +// assertFalse(s0.isUnsubscribed) +// composite -= s0 +// assertTrue(s0.isUnsubscribed) +// +// composite.unsubscribe() +// +// assertTrue(composite.isUnsubscribed) +// } +// +// @Test +// def multiAssignmentSubscriptionAdd() { +// +// val s0 = BooleanSubscription() +// val s1 = BooleanSubscription() +// val multiple = MultipleAssignmentSubscription() +// +// assertFalse(multiple.isUnsubscribed) +// +// multiple.subscription = s0 +// assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) +// +// multiple.subscription = s1 +// assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) +// +// assertFalse(s0.isUnsubscribed) +// assertFalse(s1.isUnsubscribed) +// +// multiple.unsubscribe() +// +// assertTrue(multiple.isUnsubscribed) +// assertFalse(s0.isUnsubscribed) +// assertTrue(s1.isUnsubscribed) +// +// val s2 = BooleanSubscription() +// assertFalse(s2.isUnsubscribed) +// multiple.subscription = s2 +// assertTrue(s2.isUnsubscribed) +// } +// +//} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala deleted file mode 100644 index baa6142b98..0000000000 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala +++ /dev/null @@ -1,121 +0,0 @@ -package rx.lang.scala.subscriptionstest - -import org.junit.Assert._ -import org.junit.Test -import org.scalatest.junit.JUnitSuite -import rx.lang.scala -import rx.lang.scala.Subscription -import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription, BooleanSubscription} - - -class SubscriptionTests extends JUnitSuite { - - @Test - def anonymousSubscriptionCreate() { - throw new Exception("WTF") - //val subscription = rx.lang.scala.Subscription{} - //assertNotNull(subscription) - } - - @Test - def anonymousSubscriptionDispose() { - //var unsubscribed = false - //val subscription = Subscription{ unsubscribed = true } - //assertFalse(unsubscribed) - //subscription.unsubscribe() - //assertTrue(unsubscribed) - } - - @Test - def emptySubscription() { - val subscription = Subscription() - subscription.unsubscribe() - } - - @Test - def booleanSubscription() { - val subscription = BooleanSubscription() - assertFalse(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - } - - @Test - def compositeSubscriptionAdd() { - - var u0 = false - val s0 = BooleanSubscription{ u0 = true } - - var u1 = false - val s1 = rx.lang.scala.Subscription{ u1 = true } - - val composite = CompositeSubscription() - - assertFalse(composite.isUnsubscribed) - - composite += s0 - composite += s1 - - composite.unsubscribe() - - assertTrue(composite.isUnsubscribed) - assertTrue(s0.isUnsubscribed) - assertTrue(u0) - assertTrue(u1) - - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - composite += s2 - assertTrue(s2.isUnsubscribed) - - } - - @Test - def compositeSubscriptionRemove() { - - val s0 = BooleanSubscription() - val composite = CompositeSubscription() - - composite += s0 - assertFalse(s0.isUnsubscribed) - composite -= s0 - assertTrue(s0.isUnsubscribed) - - composite.unsubscribe() - - assertTrue(composite.isUnsubscribed) - } - - @Test - def multiAssignmentSubscriptionAdd() { - - val s0 = BooleanSubscription() - val s1 = BooleanSubscription() - val multiple = MultipleAssignmentSubscription() - - assertFalse(multiple.isUnsubscribed) - - multiple.subscription = s0 - assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) - - multiple.subscription = s1 - assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) - - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) - - multiple.unsubscribe() - - assertTrue(multiple.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertTrue(s1.isUnsubscribed) - - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - multiple.subscription = s2 - assertTrue(s2.isUnsubscribed) - } - -} From 98dee164e404c5d18fd9b74e57d6dec12672b3c6 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 01:07:50 -0800 Subject: [PATCH 011/441] Modified Subscription tests. --- .../scala/rx/lang/scala/Subscription.scala | 14 +- .../rx/lang/scala/SubscriptionTests.scala | 223 ++++++++---------- 2 files changed, 106 insertions(+), 131 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index 16e6229497..7cc221ff78 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -29,19 +29,18 @@ trait Subscription { private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { override def unsubscribe(){ Subscription.this.unsubscribe(); - Subscription.this.unsubscribed.set(true) } } + /** * Call this method to stop receiving notifications on the Observer that was registered when * this Subscription was received. */ - def unsubscribe(): Unit = { } + def unsubscribe(): Unit = { unsubscribed.set(true) } /** * Checks if the subscription is unsubscribed. - * You typically do not want to override this. */ def isUnsubscribed: Boolean = unsubscribed.get() private [scala] val unsubscribed = new AtomicBoolean(false) @@ -69,8 +68,15 @@ object Subscription { */ def apply(u: => Unit): Subscription = { new Subscription() { - override def unsubscribe(): Unit = { u } + override def unsubscribe(): Unit = { + if(!super.isUnsubscribed) { u; super.unsubscribe() } + } } } + /** + * Checks if the subscription is unsubscribed. + */ + def apply(): Subscription = { new Subscription {} } + } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index d60125d3cd..4719e54367 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -8,139 +8,108 @@ import scala.concurrent.duration._ import scala.language.postfixOps import org.mockito.Mockito._ import org.mockito.Matchers._ +import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription} class SubscriptionTests extends JUnitSuite { @Test - def anonymousSubscriptionCreate() { - val subscription = rx.lang.scala.Subscription{} - assertNotNull(subscription) + def subscriptionCreate() { + + val subscription = Subscription() + + assertFalse(subscription.isUnsubscribed) + + subscription.unsubscribe() + assertTrue(subscription.isUnsubscribed) } @Test - def anonymousSubscriptionDispose() { - var unsubscribed = false - val subscription = Subscription{ unsubscribed = true } - assertFalse(unsubscribed) + def subscriptionUnsubscribeIdempotent() { + var called = false + + val subscription = Subscription{ called = !called } + + assertFalse(called) + assertFalse(subscription.isUnsubscribed) + subscription.unsubscribe() - assertTrue(unsubscribed) + assertTrue(called) + assertTrue(subscription.isUnsubscribed) + + subscription.unsubscribe() + assertTrue(called) + assertTrue(subscription.isUnsubscribed) } -} -// -//import org.junit.Assert._ -//import org.junit._ -//import org.scalatest.junit.JUnitSuite -//import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription, BooleanSubscription} -// -//@Ignore -//class SubscriptionTests extends JUnitSuite { -// -// @Test -// def anonymousSubscriptionCreate() { -// throw new Exception("WTF") -// //val subscription = rx.lang.scala.Subscription{} -// //assertNotNull(subscription) -// } -// -// @Test -// def anonymousSubscriptionDispose() { -// //var unsubscribed = false -// //val subscription = Subscription{ unsubscribed = true } -// //assertFalse(unsubscribed) -// //subscription.unsubscribe() -// //assertTrue(unsubscribed) -// } -// -// @Test -// def emptySubscription() { -// val subscription = Subscription() -// subscription.unsubscribe() -// } -// -// @Test -// def booleanSubscription() { -// val subscription = BooleanSubscription() -// assertFalse(subscription.isUnsubscribed) -// subscription.unsubscribe() -// assertTrue(subscription.isUnsubscribed) -// subscription.unsubscribe() -// assertTrue(subscription.isUnsubscribed) -// } -// -// @Test -// def compositeSubscriptionAdd() { -// -// var u0 = false -// val s0 = BooleanSubscription{ u0 = true } -// -// var u1 = false -// val s1 = rx.lang.scala.Subscription{ u1 = true } -// -// val composite = CompositeSubscription() -// -// assertFalse(composite.isUnsubscribed) -// -// composite += s0 -// composite += s1 -// -// composite.unsubscribe() -// -// assertTrue(composite.isUnsubscribed) -// assertTrue(s0.isUnsubscribed) -// assertTrue(u0) -// assertTrue(u1) -// -// val s2 = BooleanSubscription() -// assertFalse(s2.isUnsubscribed) -// composite += s2 -// assertTrue(s2.isUnsubscribed) -// -// } -// -// @Test -// def compositeSubscriptionRemove() { -// -// val s0 = BooleanSubscription() -// val composite = CompositeSubscription() -// -// composite += s0 -// assertFalse(s0.isUnsubscribed) -// composite -= s0 -// assertTrue(s0.isUnsubscribed) -// -// composite.unsubscribe() -// -// assertTrue(composite.isUnsubscribed) -// } -// -// @Test -// def multiAssignmentSubscriptionAdd() { -// -// val s0 = BooleanSubscription() -// val s1 = BooleanSubscription() -// val multiple = MultipleAssignmentSubscription() -// -// assertFalse(multiple.isUnsubscribed) -// -// multiple.subscription = s0 -// assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) -// -// multiple.subscription = s1 -// assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) -// -// assertFalse(s0.isUnsubscribed) -// assertFalse(s1.isUnsubscribed) -// -// multiple.unsubscribe() -// -// assertTrue(multiple.isUnsubscribed) -// assertFalse(s0.isUnsubscribed) -// assertTrue(s1.isUnsubscribed) -// -// val s2 = BooleanSubscription() -// assertFalse(s2.isUnsubscribed) -// multiple.subscription = s2 -// assertTrue(s2.isUnsubscribed) -// } -// -//} + @Test + def compositeSubscriptionAdd() { + + val s0 = Subscription() + val s1 = Subscription() + + val composite = CompositeSubscription() + + assertFalse(composite.isUnsubscribed) + + composite += s0 + composite += s1 + + composite.unsubscribe() + + assertTrue(composite.isUnsubscribed) + assertTrue(s0.isUnsubscribed) + assertTrue(s0.isUnsubscribed) + + val s2 = Subscription{} + assertFalse(s2.isUnsubscribed) + composite += s2 + assertTrue(s2.isUnsubscribed) + + } + + @Test + def compositeSubscriptionRemove() { + + val s0 = Subscription() + val composite = CompositeSubscription() + + composite += s0 + assertFalse(s0.isUnsubscribed) + + composite -= s0 + assertTrue(s0.isUnsubscribed) + + composite.unsubscribe() + assertTrue(composite.isUnsubscribed) + } + + @Test + def multiAssignmentSubscriptionAdd() { + + val s0 = Subscription() + val s1 = Subscription() + val multiple = MultipleAssignmentSubscription() + + assertFalse(multiple.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) + + multiple.subscription = s0 + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) + + multiple.subscription = s1 + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) + + multiple.unsubscribe() + assertTrue(multiple.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertTrue(s1.isUnsubscribed) + + val s2 = Subscription() + assertFalse(s2.isUnsubscribed) + multiple.subscription = s2 + assertTrue(s2.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + } +} From 0a2cf15e92a22158a6e6d8f0c0bafbe843be26ce Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 01:25:59 -0800 Subject: [PATCH 012/441] Modified Subscription tests. --- .../rxjava-scala/ReleaseNotes.md | 53 ++++++++++++++----- .../main/scala/rx/lang/scala/Scheduler.scala | 1 + .../subscriptions/BooleanSubscription.scala | 21 -------- 3 files changed, 42 insertions(+), 33 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 72183163fd..af97e80d4b 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -87,10 +87,10 @@ class XXXSubject[T] private[scala] (val asJavaSubject: rx.subjects.XXXSubject[T] The subjects that are available are: -* AsyncSubject[T]() -* BehaviorSubject[T](T value) -* PublishSubject[T]() -* ReplaySubject[T]() +* `AsyncSubject[T]()` +* `BehaviorSubject[T](value)` +* `PublishSubject[T]()` +* `ReplaySubject[T]()` The latter is still missing various overloads http://msdn.microsoft.com/en-us/library/hh211810(v=vs.103).aspx which you can expect to appear once they are added to the underlying RxJava implementation. @@ -120,20 +120,49 @@ which already deviated from the pattern. In this release, we changed this to make scheduler more like `Subject` and provide a family of schedulers that you create using their factory function: -* CurrentThreadScheduler() -* ExecutorScheduler(executor: Executor) -* ImmediateScheduler() -* NewThreadScheduler() -* ScheduledExecutorServiceScheduler(executor: ScheduledExecutorService) -* TestScheduler() -* ThreadPoolForComputationScheduler() -* ThreadPoolForIOScheduler() +* `CurrentThreadScheduler()` +* `ExecutorScheduler(executor)` +* `ImmediateScheduler()` +* `NewThreadScheduler()` +* `ScheduledExecutorServiceScheduler(scheduledExecutorService)` +* `TestScheduler()` +* `ThreadPoolForComputationScheduler()` +* `ThreadPoolForIOScheduler()` In the future we expect that this list will grow further. To make your code compile in the new release you will have to change all occurrences of `Schedulers.xxx` into `XxxScheduler()`. +Subscriptions +------------- + +The `Subscription` trait in Scala now has `isUnsubscribed` as a member, effectively collapsing the old `Subscription` +and `BooleanSubscription`, and the latter has been removed from the public surface. Pending a bugfix in RxJava, +`SerialSubscription` implements its own `isUnsubscribed`. + + +```scala +trait Subscription { + + private [scala] val asJavaSubscription: rx.Subscription = {...} + private [scala] val unsubscribed = new AtomicBoolean(false) + + def unsubscribe(): Unit = { unsubscribed.set(true) } + def isUnsubscribed: Boolean = unsubscribed.get() +} + +object Subscription {...} + ``` + + To create a `Subscription` use one of the following factory methods: + + * `Subscription{...}`, `Subscription()` + * `CompositeSubscription(subscriptions)` + * `MultipleAssignmentSubscription` + * `SerialSubscription` + + In case you do feel tempted to call `new Subscription{ ...}` directly make sure you wire up `isUnsubscribed` properly. Notifications ------------- diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 0098fc8954..918c34ae92 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -212,6 +212,7 @@ trait Scheduler { } +// TODO add switch statement to pick specific constructor so you can downcast private [scala] object Scheduler { def apply(scheduler: rx.Scheduler): Scheduler = { new Scheduler() { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index f3c5b83fec..a299299f21 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -17,27 +17,6 @@ package rx.lang.scala.subscriptions import rx.lang.scala._ -private [scala] object BooleanSubscription { - - /** - * Creates a [[rx.lang.scala.subscriptions.BooleanSubscription]]. - */ - def apply(): BooleanSubscription = { - new BooleanSubscription(new rx.subscriptions.BooleanSubscription()) - } - - /** - * Creates a [[rx.lang.scala.subscriptions.BooleanSubscription]] that invokes the specified action when unsubscribed. - */ - def apply(u: => Unit): BooleanSubscription = { - new BooleanSubscription(new rx.subscriptions.BooleanSubscription { - override def unsubscribe(): Unit = { - if(!super.isUnsubscribed) { u; super.unsubscribe() } - } - }) - } -} - /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ From 8128bbe08a8bdc13383019c8237e9d8f75546ce7 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 01:30:45 -0800 Subject: [PATCH 013/441] Modified Subscription tests. --- language-adaptors/rxjava-scala/ReleaseNotes.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index af97e80d4b..64858778a2 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -72,8 +72,8 @@ trait Subject[-T, +R] extends Observable[R] with Observer[T] { } ``` -There is no companion object for `Subject` but instead there are a number of subtypes for each kind of subject, -that follows the pattern of a companion object and a class with a private constructor: +*I will remove PublishSubject making it *Subject* There is no companion object for `Subject` but instead* +For each kind of subject, there is a pair of a companion object and a class with a private constructor: ```scala object XXXSubject { @@ -89,7 +89,7 @@ The subjects that are available are: * `AsyncSubject[T]()` * `BehaviorSubject[T](value)` -* `PublishSubject[T]()` +* `Subject[T]()` * `ReplaySubject[T]()` The latter is still missing various overloads http://msdn.microsoft.com/en-us/library/hh211810(v=vs.103).aspx which From 8b039f5b8bdb4dcc18593251a4443f08891e3f9f Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:17:39 +0100 Subject: [PATCH 014/441] add OperationTimer --- .../java/rx/operators/OperationTimer.java | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationTimer.java diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java new file mode 100644 index 0000000000..3bb462cac0 --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java @@ -0,0 +1,74 @@ +/** + * 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 java.util.concurrent.TimeUnit; + +import rx.Observable.OnSubscribeFunc; +import rx.Observer; +import rx.Scheduler; +import rx.Subscription; +import rx.concurrency.Schedulers; +import rx.subscriptions.Subscriptions; +import rx.util.functions.Action0; + +public final class OperationTimer { + + public static OnSubscribeFunc timer(long interval, TimeUnit unit) { + return timer(interval, unit, Schedulers.threadPoolForComputation()); + } + + public static OnSubscribeFunc timer(final long delay, final TimeUnit unit, final Scheduler scheduler) { + return new OnSubscribeFunc() { + @Override + public Subscription onSubscribe(Observer observer) { + return new Timer(delay, unit, scheduler, observer).start(); + } + }; + } + + private static class Timer { + private final long period; + private final TimeUnit unit; + private final Scheduler scheduler; + private final Observer observer; + + private Timer(long period, TimeUnit unit, Scheduler scheduler, Observer observer) { + this.period = period; + this.unit = unit; + this.scheduler = scheduler; + this.observer = observer; + } + + public Subscription start() { + final Subscription s = scheduler.schedule(new Action0() { + @Override + public void call() { + observer.onNext(null); + observer.onCompleted(); + } + }, period, unit); + + return Subscriptions.create(new Action0() { + @Override + public void call() { + s.unsubscribe(); + } + }); + } + } + +} From 4deca78d518eb4acf8d33e840bba8b336ad10c6c Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:26:41 +0100 Subject: [PATCH 015/441] add timer methods in Observable.java --- rxjava-core/src/main/java/rx/Observable.java | 28 ++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 9482a5f09f..4b8af9c94b 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -91,6 +91,7 @@ import rx.operators.OperationThrottleFirst; import rx.operators.OperationTimeInterval; import rx.operators.OperationTimeout; +import rx.operators.OperationTimer; import rx.operators.OperationTimestamp; import rx.operators.OperationToMap; import rx.operators.OperationToMultimap; @@ -1990,6 +1991,33 @@ public static Observable interval(long interval, TimeUnit unit, Scheduler return create(OperationInterval.interval(interval, unit, scheduler)); } + /** + * Emits one item after a given delay, and then completes. + * + * @param interval + * interval size in time units + * @param unit + * time units to use for the interval size + */ + public static Observable timer(long interval, TimeUnit unit) { + return create(OperationTimer.timer(interval, unit)); + } + + /** + * Emits one item after a given delay, and then completes. + * + * @param interval + * interval size in time units + * @param unit + * time units to use for the interval size + * @param scheduler + * the scheduler to use for scheduling the item + */ + public static Observable timer(long interval, TimeUnit unit, + Scheduler scheduler) { + return create(OperationTimer.timer(interval, unit, scheduler)); + } + /** * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. From 82641f971e13879b859072752b5db94b008dd1f8 Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:30:08 +0100 Subject: [PATCH 016/441] add OperationDelay --- .../java/rx/operators/OperationDelay.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationDelay.java diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java new file mode 100644 index 0000000000..9cf44ae5fb --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java @@ -0,0 +1,42 @@ +/** + * 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 java.util.concurrent.TimeUnit; + +import rx.Observable; +import rx.Scheduler; +import rx.observables.ConnectableObservable; +import rx.util.functions.Func1; + +public final class OperationDelay { + + public static Observable delay(Observable observable, final long delay, final TimeUnit unit, final Scheduler scheduler) { + // observable.map(x => Observable.timer(t).map(_ => x).startItAlreadyNow()).concat() + Observable> seqs = observable.map(new Func1>() { + public Observable call(final T x) { + ConnectableObservable co = Observable.timer(delay, unit, scheduler).map(new Func1() { + public T call(Void ignored) { + return x; + } + }).replay(); + co.connect(); + return co; + } + }); + return Observable.concat(seqs); + } +} From d5964b1df55b739a4de774a8f64f45467987b99e Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:35:54 +0100 Subject: [PATCH 017/441] copy delay test by @jmhofer source: https://github.com/jmhofer/RxJava/blob/e9027293dadf846b64f62e91da7c5c5850ed76f5/rxjava-core/src/main/java/rx/operators/OperationDelay.java --- .../java/rx/operators/OperationDelayTest.java | 181 ++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 rxjava-core/src/test/java/rx/operators/OperationDelayTest.java diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java new file mode 100644 index 0000000000..5d6c1f9fe1 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java @@ -0,0 +1,181 @@ +package rx.operators; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.util.concurrent.TimeUnit; + +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mock; + +import rx.Observable; +import rx.Observer; +import rx.concurrency.TestScheduler; +import rx.util.functions.Func1; + +public class OperationDelayTest { + @Mock + private Observer observer; + @Mock + private Observer observer2; + + private TestScheduler scheduler; + + @Before + public void before() { + initMocks(this); + scheduler = new TestScheduler(); + } + + @Test + public void testDelay() { + Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); + Observable delayed = OperationDelay.delay(source, 500L, TimeUnit.MILLISECONDS, scheduler); + delayed.subscribe(observer); + + InOrder inOrder = inOrder(observer); + scheduler.advanceTimeTo(1499L, TimeUnit.MILLISECONDS); + verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(1500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(0L); + inOrder.verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(2400L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(2500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(1L); + inOrder.verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(3400L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(3500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(2L); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + + @Test + public void testLongDelay() { + Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); + Observable delayed = OperationDelay.delay(source, 5L, TimeUnit.SECONDS, scheduler); + delayed.subscribe(observer); + + InOrder inOrder = inOrder(observer); + + scheduler.advanceTimeTo(5999L, TimeUnit.MILLISECONDS); + verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(6000L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(0L); + scheduler.advanceTimeTo(6999L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + scheduler.advanceTimeTo(7000L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(1L); + scheduler.advanceTimeTo(7999L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + scheduler.advanceTimeTo(8000L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(2L); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verify(observer, never()).onNext(anyLong()); + inOrder.verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + + @Test + public void testDelayWithError() { + Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).map(new Func1() { + @Override + public Long call(Long value) { + if (value == 1L) { + throw new RuntimeException("error!"); + } + return value; + } + }); + Observable delayed = OperationDelay.delay(source, 1L, TimeUnit.SECONDS, scheduler); + delayed.subscribe(observer); + + InOrder inOrder = inOrder(observer); + + scheduler.advanceTimeTo(1999L, TimeUnit.MILLISECONDS); + verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + + scheduler.advanceTimeTo(2000L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onError(any(Throwable.class)); + inOrder.verify(observer, never()).onNext(anyLong()); + verify(observer, never()).onCompleted(); + + scheduler.advanceTimeTo(5000L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + inOrder.verify(observer, never()).onError(any(Throwable.class)); + verify(observer, never()).onCompleted(); + } + + // TODO activate this test once https://github.com/Netflix/RxJava/issues/552 is fixed + @Ignore + @Test + public void testDelayWithMultipleSubscriptions() { + Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); + Observable delayed = OperationDelay.delay(source, 500L, TimeUnit.MILLISECONDS, scheduler); + delayed.subscribe(observer); + delayed.subscribe(observer2); + + InOrder inOrder = inOrder(observer); + InOrder inOrder2 = inOrder(observer2); + + scheduler.advanceTimeTo(1499L, TimeUnit.MILLISECONDS); + verify(observer, never()).onNext(anyLong()); + verify(observer2, never()).onNext(anyLong()); + + scheduler.advanceTimeTo(1500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(0L); + inOrder2.verify(observer2, times(1)).onNext(0L); + + scheduler.advanceTimeTo(2499L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(anyLong()); + inOrder2.verify(observer2, never()).onNext(anyLong()); + + scheduler.advanceTimeTo(2500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(1L); + inOrder2.verify(observer2, times(1)).onNext(1L); + + verify(observer, never()).onCompleted(); + verify(observer2, never()).onCompleted(); + + scheduler.advanceTimeTo(3500L, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(2L); + inOrder2.verify(observer2, times(1)).onNext(2L); + inOrder.verify(observer, never()).onNext(anyLong()); + inOrder2.verify(observer2, never()).onNext(anyLong()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder2.verify(observer2, times(1)).onCompleted(); + + verify(observer, never()).onError(any(Throwable.class)); + verify(observer2, never()).onError(any(Throwable.class)); + } +} From 84d0b66ef66e04580ce9abf5a9084f42bd7cd14d Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:51:58 +0100 Subject: [PATCH 018/441] add delay methods in Observable.java (copied those by @jmhofer) source: https://github.com/jmhofer/RxJava/blob/18d40522bb19f80c0ff8d4079bcb925742efecf4/rxjava-core/src/main/java/rx/Observable.java --- rxjava-core/src/main/java/rx/Observable.java | 34 ++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 4b8af9c94b..6a4b930b83 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -45,6 +45,7 @@ import rx.operators.OperationDebounce; import rx.operators.OperationDefaultIfEmpty; import rx.operators.OperationDefer; +import rx.operators.OperationDelay; import rx.operators.OperationDematerialize; import rx.operators.OperationDistinct; import rx.operators.OperationDistinctUntilChanged; @@ -2013,11 +2014,40 @@ public static Observable timer(long interval, TimeUnit unit) { * @param scheduler * the scheduler to use for scheduling the item */ - public static Observable timer(long interval, TimeUnit unit, - Scheduler scheduler) { + public static Observable timer(long interval, TimeUnit unit, Scheduler scheduler) { return create(OperationTimer.timer(interval, unit, scheduler)); } + /** + * Returns an Observable that emits the results of shifting the items emitted by the source + * Observable by a specified delay. Errors emitted by the source Observable are not delayed. + * @param delay + * the delay to shift the source by + * @param unit + * the {@link TimeUnit} in which period is defined + * @return the source Observable, but shifted by the specified delay + * @see MSDN: Observable.Delay + */ + public Observable delay(long delay, TimeUnit unit) { + return OperationDelay.delay(this, delay, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Returns an Observable that emits the results of shifting the items emitted by the source + * Observable by a specified delay. Errors emitted by the source Observable are not delayed. + * @param delay + * the delay to shift the source by + * @param unit + * the {@link TimeUnit} in which period is defined + * @param scheduler + * the {@link Scheduler} to use for delaying + * @return the source Observable, but shifted by the specified delay + * @see MSDN: Observable.Delay + */ + public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { + return OperationDelay.delay(this, delay, unit, scheduler); + } + /** * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. From 90cdbc3a80a8c939976bcbfb5f81e8a76bef275f Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Fri, 6 Dec 2013 16:54:45 +0100 Subject: [PATCH 019/441] make OperationDelayTest test Observable.delay instead of OperationDelay.delay --- .../src/test/java/rx/operators/OperationDelayTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java index 5d6c1f9fe1..224a82be55 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java @@ -38,7 +38,7 @@ public void before() { @Test public void testDelay() { Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); - Observable delayed = OperationDelay.delay(source, 500L, TimeUnit.MILLISECONDS, scheduler); + Observable delayed = source.delay(500L, TimeUnit.MILLISECONDS, scheduler); delayed.subscribe(observer); InOrder inOrder = inOrder(observer); @@ -78,7 +78,7 @@ public void testDelay() { @Test public void testLongDelay() { Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); - Observable delayed = OperationDelay.delay(source, 5L, TimeUnit.SECONDS, scheduler); + Observable delayed = source.delay(5L, TimeUnit.SECONDS, scheduler); delayed.subscribe(observer); InOrder inOrder = inOrder(observer); @@ -115,7 +115,7 @@ public Long call(Long value) { return value; } }); - Observable delayed = OperationDelay.delay(source, 1L, TimeUnit.SECONDS, scheduler); + Observable delayed = source.delay(1L, TimeUnit.SECONDS, scheduler); delayed.subscribe(observer); InOrder inOrder = inOrder(observer); @@ -141,7 +141,7 @@ public Long call(Long value) { @Test public void testDelayWithMultipleSubscriptions() { Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3); - Observable delayed = OperationDelay.delay(source, 500L, TimeUnit.MILLISECONDS, scheduler); + Observable delayed = source.delay(500L, TimeUnit.MILLISECONDS, scheduler); delayed.subscribe(observer); delayed.subscribe(observer2); From 4d1506cee0a38aae2dd836a3f88013fe6f13f33c Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 09:50:47 -0800 Subject: [PATCH 020/441] Added overloads for Observer companion object --- .../rxjava-scala/ReleaseNotes.md | 16 +++++++-------- .../main/scala/rx/lang/scala/Observer.scala | 20 +++++++++++++++++-- 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 64858778a2..39610580a8 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -9,8 +9,7 @@ that lay at the heart of Rx. Observer -------- -In this release we have made the constructor in the companion object `Observer` and the `asJavaObserver` property -in `Observable[T]`private to the Scala bindings package. +In this release we have made the `asJavaObserver` property in `Observable[T]`private to the Scala bindings package. ```scala trait Observer[-T] { @@ -21,10 +20,10 @@ trait Observer[-T] { def onCompleted(): Unit } -private [scala] object Observer {…} +object Observer {…} ``` -To create an instance of say `Observer[String]` in user code, you create a new instance of the `Observer` trait +To create an instance of say `Observer[String]` in user code, you can create a new instance of the `Observer` trait and implement any of the methods that you care about: ```scala val printObserver = new Observer[String] { @@ -33,14 +32,15 @@ and implement any of the methods that you care about: override def onCompleted(): Unit = {...} } ``` + or you can use one of the overloads of the companion `Observer` object by passing in implementations of the `onNext`, + `onError` or `onCompleted` methods. Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` (for instance `subscribe`) usually come with overloads that accept the individual methods -`onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you. +`onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you under the covers. -While *technically* it is a breaking change to make the companion object `Observer` and the `asJavaObserver` property -private, you should probably not have touched `asjavaObserver` in the first place.In the future we may make the -`Observer` companion object public and add overloads that take functions corresponding to the `Observer` methods. +While *technically* it is a breaking change make the `asJavaObserver` property +private, you should probably not have touched `asjavaObserver` in the first place. Observable ---------- diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index 74e5602fdd..7e341aa7d9 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -57,11 +57,11 @@ trait Observer[-T] { } -private [scala] object Observer { +object Observer { /** * Assume that the underlying rx.Observer does not need to be wrapped. */ - def apply[T](observer: rx.Observer[T]) : Observer[T] = { + private [scala] def apply[T](observer: rx.Observer[T]) : Observer[T] = { new Observer[T] { override def asJavaObserver = observer @@ -72,4 +72,20 @@ private [scala] object Observer { } } + + def apply[T]( ): Observer[T] = apply(v=>{}, e=>{}, ()=>{}) + def apply[T](onNext: T=>Unit ): Observer[T] = apply(onNext, e=>{}, ()=>{}) + def apply[T]( onError: Throwable=>Unit ): Observer[T] = apply(v=>{}, onError, ()=>{}) + def apply[T]( onCompleted: ()=>Unit): Observer[T] = apply(v=>{}, e=>{}, onCompleted) + def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply(onNext, onError, ()=>{}) + def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(onNext, e=>{}, onCompleted) + def apply[T]( onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(v=>{}, onError, onCompleted) + def apply[T](onNext: T=>Unit, onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = { + val n = onNext; val e = onError; val c = onCompleted + new Observer[T] { + override def onNext(value: T): Unit = n(value) + override def onError(error: Throwable): Unit = e(error) + override def onCompleted(): Unit = c() + } + } } \ No newline at end of file From 8b77db1639208bd83817da166e95975b34c59c6b Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 10:25:56 -0800 Subject: [PATCH 021/441] Release notes for Notification --- .../rxjava-scala/ReleaseNotes.md | 36 ++++++++++++------- .../scala/rx/lang/scala/Notification.scala | 29 ++++++++------- 2 files changed, 40 insertions(+), 25 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 39610580a8..fc84190258 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -9,7 +9,8 @@ that lay at the heart of Rx. Observer -------- -In this release we have made the `asJavaObserver` property in `Observable[T]`private to the Scala bindings package. +In this release we have made the `asJavaObserver` property in `Observable[T]`as well the the factory method in the + companion object that takes an `rx.Observer` private to the Scala bindings package. ```scala trait Observer[-T] { @@ -33,7 +34,7 @@ and implement any of the methods that you care about: } ``` or you can use one of the overloads of the companion `Observer` object by passing in implementations of the `onNext`, - `onError` or `onCompleted` methods. + `onError` or `onCompleted` methods. The advantage of this is that you get type inference as in `Observer(println(_))`. Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` (for instance `subscribe`) usually come with overloads that accept the individual methods @@ -103,6 +104,7 @@ Schedulers The biggest breaking change compared to the 0.15.1 release is giving `Scheduler` the same structure as the other types. The trait itself remains unchanged, except that we made the underlying Java representation hidden as above. +The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.lang.scala.schedulers`. ```scala trait Scheduler { @@ -129,10 +131,11 @@ that you create using their factory function: * `ThreadPoolForComputationScheduler()` * `ThreadPoolForIOScheduler()` -In the future we expect that this list will grow further. +In the future we expect that this list will grow further with new schedulers as they are imported from .NET +(http://msdn.microsoft.com/en-us/library/system.reactive.concurrency(v=vs.103).aspx). To make your code compile in the new release you will have to change all occurrences of `Schedulers.xxx` -into `XxxScheduler()`. +into `XxxScheduler()`, and import `rx.lang.scala.schedulers` instead of `rx.lang.scala.concurrency`. Subscriptions ------------- @@ -148,8 +151,8 @@ trait Subscription { private [scala] val asJavaSubscription: rx.Subscription = {...} private [scala] val unsubscribed = new AtomicBoolean(false) - def unsubscribe(): Unit = { unsubscribed.set(true) } - def isUnsubscribed: Boolean = unsubscribed.get() + def unsubscribe(): Unit = { ... } + def isUnsubscribed: Boolean = ... } object Subscription {...} @@ -162,19 +165,28 @@ object Subscription {...} * `MultipleAssignmentSubscription` * `SerialSubscription` - In case you do feel tempted to call `new Subscription{ ...}` directly make sure you wire up `isUnsubscribed` properly. + In case you do feel tempted to call `new Subscription{ ...}` directly make sure you wire up `isUnsubscribed` + and with the `unsubscribed` field properly, but for all practical purposes you should just use one of the factory methods. Notifications ------------- +All underlying wrapped `Java` types in the `Notification` trait are made private like all previous types. The companion +`Notification` now has both constructor and destructor functions: + ```scala object Notification {…} trait Notification[+T] { - def asJavaNotification: rx.Notification[_ <: T] + private [scala] def asJavaNotification: rx.Notification[_ <: T] } -object Subscription {…} -trait Subscription { - def asJavaSubscription: rx.Subscription +object Notification { + object OnNext { def apply(...){}; def unapply(..){...} } + object OnError { def apply(...){}; def unapply(..){...} } + object OnCompleted { def apply(...){}; def unapply(..){...} } } -``` \ No newline at end of file +``` +To construct a `Notification`, you use `Notification.OnNext("hello")`, or `Notification.OnError`(new Exception("Oops!"))`. +To pattern match on a notification you can create a partial function like so: `case OnNext(v) => { ... v ... }`. + +There are no breaking changes for notifications. diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index 21491bc96b..6671fb707f 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -19,7 +19,7 @@ package rx.lang.scala * Emitted by Observables returned by [[rx.lang.scala.Observable.materialize]]. */ sealed trait Notification[+T] { - def asJava: rx.Notification[_ <: T] + private [scala] def asJava: rx.Notification[_ <: T] } /** @@ -37,7 +37,7 @@ sealed trait Notification[+T] { */ object Notification { - def apply[T](n: rx.Notification[_ <: T]): Notification[T] = n.getKind match { + private [scala] def apply[T](n: rx.Notification[_ <: T]): Notification[T] = n.getKind match { case rx.Notification.Kind.OnNext => new OnNext(n) case rx.Notification.Kind.OnCompleted => new OnCompleted(n) case rx.Notification.Kind.OnError => new OnError(n) @@ -46,9 +46,7 @@ object Notification { // OnNext, OnError, OnCompleted are not case classes because we don't want pattern matching // to extract the rx.Notification - class OnNext[+T](val asJava: rx.Notification[_ <: T]) extends Notification[T] { - def value: T = asJava.getValue - } + object OnNext { @@ -57,13 +55,13 @@ object Notification { } def unapply[U](n: Notification[U]): Option[U] = n match { - case n2: OnNext[U] => Some(n.asJava.getValue) + case n2: OnNext[U] => Some(n.getValue) case _ => None } } - - class OnError[+T](val asJava: rx.Notification[_ <: T]) extends Notification[T] { - def error: Throwable = asJava.getThrowable + + class OnNext[+T] private[scala] (val asJava: rx.Notification[_ <: T]) extends Notification[T] { + def value: T = asJava.getValue } object OnError { @@ -73,13 +71,15 @@ object Notification { } def unapply[U](n: Notification[U]): Option[Throwable] = n match { - case n2: OnError[U] => Some(n2.asJava.getThrowable) + case n2: OnError[U] => Some(n2.error) case _ => None } } - - class OnCompleted[T](val asJava: rx.Notification[_ <: T]) extends Notification[T] {} - + + class OnError[+T] private[scala] (val asJava: rx.Notification[_ <: T]) extends Notification[T] { + def error: Throwable = asJava.getThrowable + } + object OnCompleted { def apply[T](): Notification[T] = { @@ -92,5 +92,8 @@ object Notification { } } + class OnCompleted[T] private[scala](val asJava: rx.Notification[_ <: T]) extends Notification[T] {} + + } From a565cc09bc3aa9daa560d57ef9b629a77d3058cd Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 10:37:02 -0800 Subject: [PATCH 022/441] Cosmetic changes to Notification. Cleaned up overloads for Observer. --- .../main/scala/rx/lang/scala/Notification.scala | 14 +++++++------- .../src/main/scala/rx/lang/scala/Observer.scala | 3 --- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index 6671fb707f..9c108350d7 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -19,7 +19,7 @@ package rx.lang.scala * Emitted by Observables returned by [[rx.lang.scala.Observable.materialize]]. */ sealed trait Notification[+T] { - private [scala] def asJava: rx.Notification[_ <: T] + private [scala] val asJava: rx.Notification[_ <: T] } /** @@ -54,8 +54,8 @@ object Notification { Notification(new rx.Notification[T](value)) } - def unapply[U](n: Notification[U]): Option[U] = n match { - case n2: OnNext[U] => Some(n.getValue) + def unapply[U](notification: Notification[U]): Option[U] = notification match { + case onNext: OnNext[U] => Some(onNext.value) case _ => None } } @@ -70,8 +70,8 @@ object Notification { Notification(new rx.Notification[T](error)) } - def unapply[U](n: Notification[U]): Option[Throwable] = n match { - case n2: OnError[U] => Some(n2.error) + def unapply[U](notification: Notification[U]): Option[Throwable] = notification match { + case onError: OnError[U] => Some(onError.error) case _ => None } } @@ -86,8 +86,8 @@ object Notification { Notification(new rx.Notification()) } - def unapply[U](n: Notification[U]): Option[Unit] = n match { - case n2: OnCompleted[U] => Some() + def unapply[U](notification: Notification[U]): Option[Unit] = notification match { + case onCompleted: OnCompleted[U] => Some() case _ => None } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index 7e341aa7d9..b8cd9add1e 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -75,11 +75,8 @@ object Observer { def apply[T]( ): Observer[T] = apply(v=>{}, e=>{}, ()=>{}) def apply[T](onNext: T=>Unit ): Observer[T] = apply(onNext, e=>{}, ()=>{}) - def apply[T]( onError: Throwable=>Unit ): Observer[T] = apply(v=>{}, onError, ()=>{}) - def apply[T]( onCompleted: ()=>Unit): Observer[T] = apply(v=>{}, e=>{}, onCompleted) def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply(onNext, onError, ()=>{}) def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(onNext, e=>{}, onCompleted) - def apply[T]( onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(v=>{}, onError, onCompleted) def apply[T](onNext: T=>Unit, onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = { val n = onNext; val e = onError; val c = onCompleted new Observer[T] { From ceb0574094b187912faeb0f689ed6579efc88ee1 Mon Sep 17 00:00:00 2001 From: David Gross Date: Fri, 6 Dec 2013 10:52:38 -0800 Subject: [PATCH 023/441] More precise marble diagram for the case when zip() takes an Observable that emits Observables --- 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 9482a5f09f..fd62808124 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -3309,7 +3309,7 @@ public Observable> window(long timespan, long timeshift, TimeUnit * 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 From a0aa6db735481652fd9fab4c21ab7f83928efb22 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 10:55:44 -0800 Subject: [PATCH 024/441] Renamed rx.lang.scala.concurrency to rx.lang.scala.schedulers Fixed Scheduler constructor to map to correct scheduler type. --- language-adaptors/rxjava-scala/ReleaseNotes.md | 4 ++-- .../scala/rx/lang/scala/examples/RxScalaDemo.scala | 2 +- .../lang/scala/examples/TestSchedulerExample.scala | 2 +- .../src/main/scala/rx/lang/scala/Scheduler.scala | 14 +++++++++----- .../main/scala/rx/lang/scala/Subscription.scala | 4 +--- .../CurrentThreadScheduler.scala | 2 +- .../ExecutorScheduler.scala | 2 +- .../ImmediateScheduler.scala | 2 +- .../NewThreadScheduler.scala | 2 +- .../ScheduledExecutorServiceScheduler.scala | 2 +- .../TestScheduler.scala | 2 +- .../ThreadPoolForComputationScheduler.scala | 4 ++-- .../ThreadPoolForIOScheduler.scala | 4 ++-- .../test/scala/rx/lang/scala/SubjectTests.scala | 2 +- rxjava-core/src/test/java/rx/SchedulersTest.java | 2 +- .../rx/operators/SynchronizedObserverTest.java | 12 ++++++------ 16 files changed, 32 insertions(+), 30 deletions(-) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/CurrentThreadScheduler.scala (96%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/ExecutorScheduler.scala (97%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/ImmediateScheduler.scala (96%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/NewThreadScheduler.scala (96%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/ScheduledExecutorServiceScheduler.scala (97%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/TestScheduler.scala (98%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/ThreadPoolForComputationScheduler.scala (93%) rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/{concurrency => schedulers}/ThreadPoolForIOScheduler.scala (92%) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index fc84190258..9f96aeb58e 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -104,7 +104,7 @@ Schedulers The biggest breaking change compared to the 0.15.1 release is giving `Scheduler` the same structure as the other types. The trait itself remains unchanged, except that we made the underlying Java representation hidden as above. -The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.lang.scala.schedulers`. +The scheduler package has been renamed from `rx.lang.scala.schedulers` to `rx.lang.scala.schedulers`. ```scala trait Scheduler { @@ -135,7 +135,7 @@ In the future we expect that this list will grow further with new schedulers as (http://msdn.microsoft.com/en-us/library/system.reactive.concurrency(v=vs.103).aspx). To make your code compile in the new release you will have to change all occurrences of `Schedulers.xxx` -into `XxxScheduler()`, and import `rx.lang.scala.schedulers` instead of `rx.lang.scala.concurrency`. +into `XxxScheduler()`, and import `rx.lang.scala.schedulers` instead of `rx.lang.scala.schedulers`. Subscriptions ------------- diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala index 29ad8fc492..ef2e17125d 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala @@ -29,7 +29,7 @@ import org.junit.Test import org.scalatest.junit.JUnitSuite import rx.lang.scala.{Observer, Notification, Observable} -import rx.lang.scala.concurrency._ +import rx.lang.scala.schedulers._ import rx.lang.scala.subjects.BehaviorSubject import org.mockito.Mockito._ import scala.Some diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala index cd13396039..800cd9aaf0 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala @@ -5,7 +5,7 @@ import org.scalatest.junit.JUnitSuite import scala.concurrent.duration._ import scala.language.postfixOps import rx.lang.scala.{ Observable, Observer } -import rx.lang.scala.concurrency.TestScheduler +import rx.lang.scala.schedulers.TestScheduler import rx.lang.scala.subjects.BehaviorSubject import org.mockito.Mockito._ import org.mockito.Matchers._ diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 918c34ae92..45d0b44952 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -18,6 +18,7 @@ package rx.lang.scala import java.util.Date import scala.concurrent.duration.Duration import rx.util.functions.{Action0, Action1, Func2} +import rx.lang.scala.schedulers._ /** * Represents an object that schedules units of work. @@ -212,13 +213,16 @@ trait Scheduler { } -// TODO add switch statement to pick specific constructor so you can downcast private [scala] object Scheduler { - def apply(scheduler: rx.Scheduler): Scheduler = { - new Scheduler() { - val asJavaScheduler = scheduler - } + def apply(scheduler: rx.Scheduler): Scheduler = scheduler match { + case s: rx.concurrency.CurrentThreadScheduler => new CurrentThreadScheduler(s) + case s: rx.concurrency.ExecutorScheduler => new ExecutorScheduler(s) + case s: rx.concurrency.ImmediateScheduler => new ImmediateScheduler(s) + case s: rx.concurrency.NewThreadScheduler => new NewThreadScheduler(s) + case s: rx.concurrency.TestScheduler => new TestScheduler(s) + case s: rx.Scheduler => new Scheduler{ val asJavaScheduler = s } } + } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index 7cc221ff78..10271d95fb 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -27,9 +27,7 @@ import java.util.concurrent.atomic.AtomicBoolean trait Subscription { private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { - override def unsubscribe(){ - Subscription.this.unsubscribe(); - } + override def unsubscribe(){ Subscription.this.unsubscribe() } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/CurrentThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala similarity index 96% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/CurrentThreadScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala index 500d9c1d33..f3a7898a30 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/CurrentThreadScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ExecutorScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala similarity index 97% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ExecutorScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala index 03c7e79d44..d718c58b55 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ExecutorScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import java.util.concurrent.Executor import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ImmediateScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala similarity index 96% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ImmediateScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala index 91843a5746..7a066a3931 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ImmediateScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/NewThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala similarity index 96% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/NewThreadScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala index dc69578082..674205ba07 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/NewThreadScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ScheduledExecutorServiceScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala similarity index 97% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ScheduledExecutorServiceScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala index d6e8b11d98..20c4dc3544 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ScheduledExecutorServiceScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import java.util.concurrent.ScheduledExecutorService import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/TestScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala similarity index 98% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/TestScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala index 98a0d241b8..f8df7610b8 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/TestScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import scala.concurrent.duration.Duration import rx.lang.scala.Scheduler diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForComputationScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala similarity index 93% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForComputationScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala index 8b51083b89..b9e0791bef 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForComputationScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import rx.lang.scala.Scheduler @@ -26,7 +26,7 @@ object ThreadPoolForComputationScheduler { * * This can be used for event-loops, processing callbacks and other computational work. * - * Do not perform IO-bound work on this scheduler. Use [[rx.lang.scala.concurrency.ThreadPoolForIOScheduler]] instead. + * Do not perform IO-bound work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForIOScheduler]] instead. */ def apply(): ThreadPoolForComputationScheduler = { new ThreadPoolForComputationScheduler(rx.concurrency.Schedulers.threadPoolForComputation()) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForIOScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala similarity index 92% rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForIOScheduler.scala rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala index 8869cf96b3..63b7e6b659 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/concurrency/ThreadPoolForIOScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.lang.scala.concurrency +package rx.lang.scala.schedulers import rx.lang.scala.Scheduler @@ -26,7 +26,7 @@ object ThreadPoolForIOScheduler { * * This can be used for asynchronously performing blocking IO. * - * Do not perform computational work on this scheduler. Use [[rx.lang.scala.concurrency.ThreadPoolForComputationScheduler]] instead. + * Do not perform computational work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForComputationScheduler]] instead. */ def apply(): ThreadPoolForIOScheduler = { new ThreadPoolForIOScheduler(rx.concurrency.Schedulers.threadPoolForIO()) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 86523f331d..7879f37414 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -8,7 +8,7 @@ package rx.lang.scala //import scala.concurrent.duration._ //import scala.language.postfixOps //import rx.lang.scala.{ Observable, Observer } -//import rx.lang.scala.concurrency.TestScheduler +//import rx.lang.scala.schedulers.TestScheduler //import rx.lang.scala.subjects.BehaviorSubject //import org.mockito.Mockito._ //import org.mockito.Matchers._ diff --git a/rxjava-core/src/test/java/rx/SchedulersTest.java b/rxjava-core/src/test/java/rx/SchedulersTest.java index c9d97054d0..211556cd58 100644 --- a/rxjava-core/src/test/java/rx/SchedulersTest.java +++ b/rxjava-core/src/test/java/rx/SchedulersTest.java @@ -460,7 +460,7 @@ public void run() { } if (observer.error.get() == null) { - fail("We expected error messages due to concurrency"); + fail("We expected error messages due to schedulers"); } } diff --git a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java index f1c40c3674..cde19532a3 100644 --- a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java +++ b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java @@ -88,7 +88,7 @@ public void testMultiThreadedBasic() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -128,7 +128,7 @@ public void testMultiThreadedBasicWithLock() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -160,7 +160,7 @@ public void testMultiThreadedWithNPE() { // so commenting out for now as this is not a critical thing to test here //verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -206,7 +206,7 @@ public void testMultiThreadedWithNPEAndLock() { // so commenting out for now as this is not a critical thing to test here //verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -236,7 +236,7 @@ public void testMultiThreadedWithNPEinMiddle() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -280,7 +280,7 @@ public void testMultiThreadedWithNPEinMiddleAndLock() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have concurrency ... + // we can have schedulers ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); From f0c8cb908c99c22f33bb8581e5391c1bf453117c Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 12:54:45 -0800 Subject: [PATCH 025/441] Added test for SerialSubscription --- .../rx/lang/scala/SubscriptionTests.scala | 33 +++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index 4719e54367..0f1c96554c 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -8,7 +8,7 @@ import scala.concurrent.duration._ import scala.language.postfixOps import org.mockito.Mockito._ import org.mockito.Matchers._ -import rx.lang.scala.subscriptions.{MultipleAssignmentSubscription, CompositeSubscription} +import rx.lang.scala.subscriptions.{SerialSubscription, MultipleAssignmentSubscription, CompositeSubscription} class SubscriptionTests extends JUnitSuite { @Test @@ -98,7 +98,7 @@ class SubscriptionTests extends JUnitSuite { assertFalse(s1.isUnsubscribed) multiple.subscription = s1 - assertFalse(s0.isUnsubscribed) + assertFalse(s0.isUnsubscribed) // difference with SerialSubscription assertFalse(s1.isUnsubscribed) multiple.unsubscribe() @@ -112,4 +112,33 @@ class SubscriptionTests extends JUnitSuite { assertTrue(s2.isUnsubscribed) assertFalse(s0.isUnsubscribed) } + + @Test + def serialSubscriptionAdd() { + + val s0 = Subscription() + val s1 = Subscription() + val serial = SerialSubscription() + + assertFalse(serial.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) + + serial.subscription = s0 + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) + + serial.subscription = s1 + assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription + assertFalse(s1.isUnsubscribed) + + serial.unsubscribe() + assertTrue(serial.isUnsubscribed) + assertTrue(s1.isUnsubscribed) + + val s2 = Subscription() + assertFalse(s2.isUnsubscribed) + serial.subscription = s2 + assertTrue(s2.isUnsubscribed) + } } From 3853258ea0be0c93979f2fb0d0625945613a84ae Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 16:28:48 -0800 Subject: [PATCH 026/441] Subjects & Observers --- .../rxjava-scala/ReleaseNotes.md | 2 +- .../main/scala/rx/lang/scala/Observable.scala | 2 +- .../main/scala/rx/lang/scala/Observer.scala | 40 +++-- .../main/scala/rx/lang/scala/Subject.scala | 15 +- .../scala/rx/lang/scala/SubjectTests.scala | 147 +++++++++++------- 5 files changed, 118 insertions(+), 88 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 9f96aeb58e..010b32fd7c 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -34,7 +34,7 @@ and implement any of the methods that you care about: } ``` or you can use one of the overloads of the companion `Observer` object by passing in implementations of the `onNext`, - `onError` or `onCompleted` methods. The advantage of this is that you get type inference as in `Observer(println(_))`. + `onError` or `onCompleted` methods. Note that typically you do not need to create an `Observer` since all of the methods that accept an `Observer[T]` (for instance `subscribe`) usually come with overloads that accept the individual methods diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index a559daf360..cfc907a8b5 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -79,7 +79,7 @@ trait Observable[+T] import rx.lang.scala.observables.BlockingObservable import rx.lang.scala.ImplicitFunctionConversions._ - private [scala] def asJavaObservable: rx.Observable[_ <: T] + private [scala] val asJavaObservable: rx.Observable[_ <: T] /** * $subscribeObserverMain diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index b8cd9add1e..d4cfeab6c1 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -16,6 +16,7 @@ package rx.lang.scala import rx.joins.ObserverBase +import java.util.concurrent.atomic.AtomicBoolean /** Provides a mechanism for receiving push-based notifications. @@ -26,11 +27,7 @@ import rx.joins.ObserverBase */ trait Observer[-T] { - private [scala] def asJavaObserver: rx.Observer[_ >: T] = new ObserverBase[T] { - protected def onCompletedCore(): Unit = onCompleted() - protected def onErrorCore(error: Throwable): Unit = onError(error) - protected def onNextCore(value: T): Unit = onNext(value) - } + private [scala] val asJavaObserver: rx.Observer[_ >: T] /** * Provides the Observer with new data. @@ -39,50 +36,51 @@ trait Observer[-T] { * * The [[rx.lang.scala.Observable]] will not call this method again after it calls either `onCompleted` or `onError`. */ - def onNext(value: T): Unit = {} + def onNext(value: T): Unit /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has experienced an error condition. * * If the [[rx.lang.scala.Observable]] calls this method, it will not thereafter call `onNext` or `onCompleted`. */ - def onError(error: Throwable): Unit = {} + def onError(error: Throwable): Unit /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has finished sending push-based notifications. * * The [[rx.lang.scala.Observable]] will not call this method if it calls `onError`. */ - def onCompleted(): Unit = {} + def onCompleted(): Unit } object Observer { + /** - * Assume that the underlying rx.Observer does not need to be wrapped. + * Scala calls XXX; Java receives XXX. */ private [scala] def apply[T](observer: rx.Observer[T]) : Observer[T] = { new Observer[T] { - override def asJavaObserver = observer - - override def onNext(value: T): Unit = asJavaObserver.onNext(value) - override def onError(error: Throwable): Unit = asJavaObserver.onError(error) - override def onCompleted(): Unit = asJavaObserver.onCompleted() + val asJavaObserver = observer + def onNext(value: T): Unit = asJavaObserver.onNext(value) + def onError(error: Throwable): Unit = asJavaObserver.onError(error) + def onCompleted(): Unit = asJavaObserver.onCompleted() } + } def apply[T]( ): Observer[T] = apply(v=>{}, e=>{}, ()=>{}) def apply[T](onNext: T=>Unit ): Observer[T] = apply(onNext, e=>{}, ()=>{}) def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply(onNext, onError, ()=>{}) def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(onNext, e=>{}, onCompleted) - def apply[T](onNext: T=>Unit, onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = { - val n = onNext; val e = onError; val c = onCompleted - new Observer[T] { - override def onNext(value: T): Unit = n(value) - override def onError(error: Throwable): Unit = e(error) - override def onCompleted(): Unit = c() - } + def apply[T](n: T=>Unit, e: Throwable=>Unit, c: ()=>Unit): Observer[T] = { + // Java calls XXX; Scala receives XXX. + Observer(new rx.Observer[T]{ + def onNext(value: T): Unit = n(value) + def onError(error: Throwable): Unit = e(error) + def onCompleted(): Unit = c() + }) } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala index e4534b8055..13bcb7c756 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala @@ -23,18 +23,13 @@ import rx.joins.ObserverBase trait Subject[-T, +R] extends Observable[R] with Observer[T] { private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] - def asJavaObservable: rx.Observable[_ <: R] = asJavaSubject + val asJavaObservable: rx.Observable[_ <: R] = asJavaSubject - // temporary hack to workaround bugs in rx Subjects - override def asJavaObserver: rx.Observer[_ >: T] = new ObserverBase[T] { - protected def onNextCore(value: T) = asJavaSubject.onNext(value) - protected def onErrorCore(error: Throwable) = asJavaSubject.onError(error) - protected def onCompletedCore() = asJavaSubject.onCompleted() - } + val asJavaObserver: rx.Observer[_ >: T] = asJavaSubject + def onNext(value: T): Unit = { asJavaObserver.onNext(value)} + def onError(error: Throwable): Unit = { asJavaObserver.onError(error) } + def onCompleted() { asJavaObserver.onCompleted() } - override def onNext(value: T): Unit = asJavaObserver.onNext(value) - override def onError(error: Throwable): Unit = asJavaObserver.onError(error) - override def onCompleted(): Unit = asJavaObserver.onCompleted() } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 7879f37414..be6bb940b2 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -1,58 +1,95 @@ package rx.lang.scala +import org.junit.{Assert, Test} +import org.scalatest.junit.JUnitSuite +import scala.concurrent.duration._ +import scala.language.postfixOps +import rx.lang.scala.schedulers.TestScheduler +import rx.lang.scala.subjects.BehaviorSubject +import org.mockito.Mockito._ +import org.mockito.Matchers._ -//package rx.lang.scala.examples -// -//import org.junit.{Assert, Test} -//import org.scalatest.junit.JUnitSuite -//import scala.concurrent.duration._ -//import scala.language.postfixOps -//import rx.lang.scala.{ Observable, Observer } -//import rx.lang.scala.schedulers.TestScheduler -//import rx.lang.scala.subjects.BehaviorSubject -//import org.mockito.Mockito._ -//import org.mockito.Matchers._ -// -// @Test def PublishSubjectIsAChannel() { -// -// val channel: BehaviorSubject[Integer] = BehaviorSubject(2013) -// val observerA: Observer[Integer] = mock(classOf[Observer[Integer]]) -// val observerB: Observer[Integer] = mock(classOf[Observer[Integer]]) -// val observerC: Observer[Integer] = mock(classOf[Observer[Integer]]) -// -// val x = inOrder(observerA, observerB, observerC) -// -// val a = channel.subscribe(observerA) -// val b = channel.subscribe(observerB) -// -// x.verify(observerA).onNext(2013) -// x.verify(observerB).onNext(2013) -// -// channel.onNext(42) -// -// x.verify(observerA).onNext(42) -// x.verify(observerB).onNext(42) -// -// a.unsubscribe() -// -// channel.onNext(4711) -// -// x.verify(observerA, never()).onNext(any()) -// x.verify(observerB).onNext(4711) -// -// channel.onCompleted() -// -// x.verify(observerA, never()).onCompleted() -// x.verify(observerB).onCompleted() -// -// val c = channel.subscribe(observerC) -// -// x.verify(observerC).onCompleted() -// -// channel.onNext(13) -// -// x.verifyNoMoreInteractions() -// -// } -// -//} + +/** + * No fucking clue how to properly mock traits. + * Some old-school imperative code works just as well. + */ +class SubjectTest extends JUnitSuite { + + @Test def PublishSubjectIsAChannel() { + + var lastA: Integer = null + var errorA: Throwable = null + var completedA: Boolean = false + val observerA = Observer[Integer]( + (next: Integer) => { lastA = next }, + (error: Throwable) => { errorA = error }, + () => { completedA = true } + ) + + var lastB: Integer = null + var errorB: Throwable = null + var completedB: Boolean = false + val observerB = Observer[Integer]( + (next: Integer) => { lastB = next }, + (error: Throwable) => { errorB = error }, + () => { completedB = true } + ) + + var lastC: Integer = null + var errorC: Throwable = null + var completedC: Boolean = false + val observerC = Observer[Integer]( + (next: Integer) => { lastC = next }, + (error: Throwable) => { errorC = error }, + () => { completedC = true } + ) + + val channel: BehaviorSubject[Integer] = BehaviorSubject(2013) + + val a = channel.subscribe(observerA) + Assert.assertEquals(2013, lastA) + + val b = channel.subscribe(observerB) + Assert.assertEquals(2013, lastB) + + channel.onNext(42) + Assert.assertEquals(42, lastA) + Assert.assertEquals(42, lastB) + + a.unsubscribe() + channel.onNext(4711) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + channel.onCompleted() + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + val c = channel.subscribe(observerC) + channel.onNext(13) + + Assert.assertEquals(null, lastC) + Assert.assertTrue(completedC) + + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + channel.onError(new Exception("!")) + + Assert.assertEquals(null, lastC) + Assert.assertTrue(completedC) + + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + + } + +} \ No newline at end of file From 1ea162d89d080b653bf892c07cf77f40be79c69e Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 16:32:00 -0800 Subject: [PATCH 027/441] private [scala] val asJavaXXX for all. --- .../src/main/scala/rx/lang/scala/Observable.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index cfc907a8b5..8231481cad 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -1840,22 +1840,22 @@ object Observable { private[scala] def jObsOfListToScObsOfSeq[T](jObs: rx.Observable[_ <: java.util.List[T]]): Observable[Seq[T]] = { - val oScala1: Observable[java.util.List[T]] = new Observable[java.util.List[T]]{ def asJavaObservable = jObs } + val oScala1: Observable[java.util.List[T]] = new Observable[java.util.List[T]]{ val asJavaObservable = jObs } oScala1.map((lJava: java.util.List[T]) => lJava.asScala) } private[scala] def jObsOfJObsToScObsOfScObs[T](jObs: rx.Observable[_ <: rx.Observable[_ <: T]]): Observable[Observable[T]] = { - val oScala1: Observable[rx.Observable[_ <: T]] = new Observable[rx.Observable[_ <: T]]{ def asJavaObservable = jObs } - oScala1.map((oJava: rx.Observable[_ <: T]) => new Observable[T]{ def asJavaObservable = oJava}) + val oScala1: Observable[rx.Observable[_ <: T]] = new Observable[rx.Observable[_ <: T]]{ val asJavaObservable = jObs } + oScala1.map((oJava: rx.Observable[_ <: T]) => new Observable[T]{ val asJavaObservable = oJava}) } /** * Creates a new Scala Observable from a given Java Observable. */ private [scala] def apply[T](observable: rx.Observable[_ <: T]): Observable[T] = { - new Observable[T]{ - def asJavaObservable = observable + new Observable[T] { + val asJavaObservable = observable } } From 426e252f6355dce49584c199e7ff25713a2069b1 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 6 Dec 2013 16:50:08 -0800 Subject: [PATCH 028/441] Tried to improve type inference, alas. --- .../src/main/scala/rx/lang/scala/Observer.scala | 8 ++++---- .../src/test/scala/rx/lang/scala/SubjectTests.scala | 2 ++ 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index d4cfeab6c1..eb42e8ce81 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -71,10 +71,10 @@ object Observer { } - def apply[T]( ): Observer[T] = apply(v=>{}, e=>{}, ()=>{}) - def apply[T](onNext: T=>Unit ): Observer[T] = apply(onNext, e=>{}, ()=>{}) - def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply(onNext, onError, ()=>{}) - def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply(onNext, e=>{}, onCompleted) + def apply[T]( ): Observer[T] = apply[T]((v:T)=>(), (e: Throwable)=>(), ()=>()) + def apply[T](onNext: T=>Unit ): Observer[T] = apply[T](onNext, (e: Throwable)=>(), ()=>()) + def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply[T](onNext, onError, ()=>()) + def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply[T](onNext, (e: Throwable)=>(), onCompleted) def apply[T](n: T=>Unit, e: Throwable=>Unit, c: ()=>Unit): Observer[T] = { // Java calls XXX; Scala receives XXX. Observer(new rx.Observer[T]{ diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index be6bb940b2..8c94048e5e 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -18,6 +18,8 @@ class SubjectTest extends JUnitSuite { @Test def PublishSubjectIsAChannel() { + val zzz = Observer[Integer]() + var lastA: Integer = null var errorA: Throwable = null var completedA: Boolean = false From 405d78ddb9a037bf0e61171838a53c29f09d761b Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sat, 7 Dec 2013 09:59:34 +0100 Subject: [PATCH 029/441] release notes details --- .../rxjava-scala/ReleaseNotes.md | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 010b32fd7c..3608e8c026 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -21,7 +21,7 @@ trait Observer[-T] { def onCompleted(): Unit } -object Observer {…} +object Observer {...} ``` To create an instance of say `Observer[String]` in user code, you can create a new instance of the `Observer` trait @@ -41,7 +41,7 @@ Note that typically you do not need to create an `Observer` since all of the met `onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you under the covers. While *technically* it is a breaking change make the `asJavaObserver` property -private, you should probably not have touched `asjavaObserver` in the first place. +private, you should probably not have touched `asJavaObserver` in the first place. Observable ---------- @@ -104,14 +104,14 @@ Schedulers The biggest breaking change compared to the 0.15.1 release is giving `Scheduler` the same structure as the other types. The trait itself remains unchanged, except that we made the underlying Java representation hidden as above. -The scheduler package has been renamed from `rx.lang.scala.schedulers` to `rx.lang.scala.schedulers`. +The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.lang.scala.schedulers`. ```scala trait Scheduler { private[scala] def asJavaScheduler: rx.Scheduler; } -private [scala] object Scheduler {…} +private [scala] object Scheduler {...} ``` In the previous release, you created schedulers by selecting them from the `Schedulers` object, @@ -165,28 +165,28 @@ object Subscription {...} * `MultipleAssignmentSubscription` * `SerialSubscription` - In case you do feel tempted to call `new Subscription{ ...}` directly make sure you wire up `isUnsubscribed` + In case you do feel tempted to call `new Subscription{...}` directly make sure you wire up `isUnsubscribed` and with the `unsubscribed` field properly, but for all practical purposes you should just use one of the factory methods. Notifications ------------- All underlying wrapped `Java` types in the `Notification` trait are made private like all previous types. The companion -`Notification` now has both constructor and destructor functions: +objects of `Notification` now have both constructor (`apply`) and extractor (`unapply`) functions: ```scala -object Notification {…} +object Notification {...} trait Notification[+T] { private [scala] def asJavaNotification: rx.Notification[_ <: T] } object Notification { - object OnNext { def apply(...){}; def unapply(..){...} } - object OnError { def apply(...){}; def unapply(..){...} } - object OnCompleted { def apply(...){}; def unapply(..){...} } + object OnNext { def apply(...){}; def unapply(...){...} } + object OnError { def apply(...){}; def unapply(...){...} } + object OnCompleted { def apply(...){}; def unapply(...){...} } } ``` -To construct a `Notification`, you use `Notification.OnNext("hello")`, or `Notification.OnError`(new Exception("Oops!"))`. +To construct a `Notification`, you import `rx.lang.scala.Notification._` and use `OnNext("hello")`, or `OnError(new Exception("Oops!"))`, or `OnCompleted()`. To pattern match on a notification you can create a partial function like so: `case OnNext(v) => { ... v ... }`. There are no breaking changes for notifications. From 31a0770e632d431736e0d91e7b68c1d0b0d01f78 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 10:53:52 -0800 Subject: [PATCH 030/441] Re-instantiating commented out tests. --- .../scala/rx/lang/scala/ObservableTest.scala | 182 +++++++++--------- .../scala/rx/lang/scala/SubjectTests.scala | 2 - .../rx/lang/scala/SubscriptionTests.scala | 84 ++++---- 3 files changed, 136 insertions(+), 132 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index c00c3fd710..74a2f1dde6 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -1,88 +1,94 @@ -//package rx.lang.scala -// -//import org.junit.Assert._ -//import org.junit.{ Ignore, Test } -// -//@Ignore -//class ObservableTests extends JUnitSuite { -// -// // Tests which needn't be run: -// -// @Ignore -// def testCovariance = { -// //println("hey, you shouldn't run this test") -// -// val o1: Observable[Nothing] = Observable.from() -// val o2: Observable[Int] = o1 -// val o3: Observable[App] = o1 -// val o4: Observable[Any] = o2 -// val o5: Observable[Any] = o3 -// } -// -// // Tests which have to be run: -// -// //@Test -// //def testDematerialize() { -// //val o = Observable.from(1, 2, 3) -// //val mat = o.materialize -// //val demat = mat.dematerialize -// -// // correctly rejected: -// //val wrongDemat = Observable("hello").dematerialize -// -// //assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) -// // } -// -// // Test that Java's firstOrDefault propagates errors. -// // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse -// // should be changed accordingly. -// @Test def testJavaFirstOrDefault() { -// assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) -// assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) -// val msg = "msg6251" -// var receivedMsg = "none" -// try { -// rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single -// } catch { -// case e: Exception => receivedMsg = e.getCause().getMessage() -// } -// assertEquals(receivedMsg, msg) -// } -// -// // @Test def testFirstOrElse() { -//// def mustNotBeCalled: String = sys.error("this method should not be called") -//// def mustBeCalled: String = "this is the default value" -//// assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) -//// assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) -// // } -// -// @Test def testTestWithError() { -// val msg = "msg6251" -// var receivedMsg = "none" -// try { -// Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single -// } catch { -// case e: Exception => receivedMsg = e.getCause().getMessage() -// } -// assertEquals(receivedMsg, msg) -// } -// -// /* -// @Test def testHead() { -// val observer = mock(classOf[Observer[Int]]) -// val o = Observable().head -// val sub = o.subscribe(observer) -// -// verify(observer, never).onNext(any(classOf[Int])) -// verify(observer, never).onCompleted() -// verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) -// } -// */ -// -// //@Test def testTest() = { -// //val a: Observable[Int] = Observable.from() -// //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) -// //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") -// //} -// -//} +package rx.lang.scala + +import org.junit.{Ignore, Assert, Test} +import org.junit.Assert +import org.scalatest.junit.JUnitSuite +import scala.concurrent.duration._ +import scala.language.postfixOps +import rx.lang.scala.schedulers.TestScheduler +import rx.lang.scala.subjects.BehaviorSubject +import org.mockito.Mockito._ +import org.mockito.Matchers._ + +class ObservableTests extends JUnitSuite { + + // Tests which needn't be run: + + @Ignore + def testCovariance = { + //println("hey, you shouldn't run this test") + + val o1: Observable[Nothing] = Observable.from() + val o2: Observable[Int] = o1 + val o3: Observable[App] = o1 + val o4: Observable[Any] = o2 + val o5: Observable[Any] = o3 + } + + // Tests which have to be run: + + @Test + def testDematerialize() { + val o = Observable.from(1, 2, 3) + val mat = o.materialize + val demat = mat.dematerialize + + //correctly rejected: + //val wrongDemat = Observable("hello").dematerialize + + Assert.assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3)) +} + + // Test that Java's firstOrDefault propagates errors. + // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse + // should be changed accordingly. + @Test def testJavaFirstOrDefault() { + Assert.assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single) + Assert.assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single) + val msg = "msg6251" + var receivedMsg = "none" + try { + rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single + } catch { + case e: Exception => receivedMsg = e.getCause().getMessage() + } + Assert.assertEquals(receivedMsg, msg) + } + + @Test def testFirstOrElse() { + def mustNotBeCalled: String = sys.error("this method should not be called") + def mustBeCalled: String = "this is the default value" + Assert.assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) + Assert.assertEquals("this is the default value", Observable.from().firstOrElse(mustBeCalled).toBlockingObservable.single) + } + + @Test def testTestWithError() { + val msg = "msg6251" + var receivedMsg = "none" + try { + Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single + } catch { + case e: Exception => receivedMsg = e.getCause().getMessage() + } + Assert.assertEquals(receivedMsg, msg) + } + + /* + @Test def testHead() { + val observer = mock(classOf[Observer[Int]]) + val o = Observable().head + val sub = o.subscribe(observer) + + verify(observer, never).onNext(any(classOf[Int])) + verify(observer, never).onCompleted() + verify(observer, times(1)).onError(any(classOf[NoSuchElementException])) + } + */ + + //@Test def testTest() = { + //val a: Observable[Int] = Observable.from() + //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) + //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") + //} + +} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 8c94048e5e..be6bb940b2 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -18,8 +18,6 @@ class SubjectTest extends JUnitSuite { @Test def PublishSubjectIsAChannel() { - val zzz = Observer[Integer]() - var lastA: Integer = null var errorA: Throwable = null var completedA: Boolean = false diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index 0f1c96554c..6612a1351c 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -2,7 +2,7 @@ package rx.lang.scala import org.junit.{Assert, Test} -import org.junit.Assert._ +import org.junit.Assert import org.scalatest.junit.JUnitSuite import scala.concurrent.duration._ import scala.language.postfixOps @@ -16,10 +16,10 @@ class SubscriptionTests extends JUnitSuite { val subscription = Subscription() - assertFalse(subscription.isUnsubscribed) + Assert.assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) + Assert.assertTrue(subscription.isUnsubscribed) } @Test @@ -28,16 +28,16 @@ class SubscriptionTests extends JUnitSuite { val subscription = Subscription{ called = !called } - assertFalse(called) - assertFalse(subscription.isUnsubscribed) + Assert.assertFalse(called) + Assert.assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() - assertTrue(called) - assertTrue(subscription.isUnsubscribed) + Assert.assertTrue(called) + Assert.assertTrue(subscription.isUnsubscribed) subscription.unsubscribe() - assertTrue(called) - assertTrue(subscription.isUnsubscribed) + Assert.assertTrue(called) + Assert.assertTrue(subscription.isUnsubscribed) } @Test @@ -48,21 +48,21 @@ class SubscriptionTests extends JUnitSuite { val composite = CompositeSubscription() - assertFalse(composite.isUnsubscribed) + Assert.assertFalse(composite.isUnsubscribed) composite += s0 composite += s1 composite.unsubscribe() - assertTrue(composite.isUnsubscribed) - assertTrue(s0.isUnsubscribed) - assertTrue(s0.isUnsubscribed) + Assert.assertTrue(composite.isUnsubscribed) + Assert.assertTrue(s0.isUnsubscribed) + Assert.assertTrue(s0.isUnsubscribed) val s2 = Subscription{} - assertFalse(s2.isUnsubscribed) + Assert.assertFalse(s2.isUnsubscribed) composite += s2 - assertTrue(s2.isUnsubscribed) + Assert.assertTrue(s2.isUnsubscribed) } @@ -73,13 +73,13 @@ class SubscriptionTests extends JUnitSuite { val composite = CompositeSubscription() composite += s0 - assertFalse(s0.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) composite -= s0 - assertTrue(s0.isUnsubscribed) + Assert.assertTrue(s0.isUnsubscribed) composite.unsubscribe() - assertTrue(composite.isUnsubscribed) + Assert.assertTrue(composite.isUnsubscribed) } @Test @@ -89,28 +89,28 @@ class SubscriptionTests extends JUnitSuite { val s1 = Subscription() val multiple = MultipleAssignmentSubscription() - assertFalse(multiple.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) + Assert.assertFalse(multiple.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) + Assert.assertFalse(s1.isUnsubscribed) multiple.subscription = s0 - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) + Assert.assertFalse(s1.isUnsubscribed) multiple.subscription = s1 - assertFalse(s0.isUnsubscribed) // difference with SerialSubscription - assertFalse(s1.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) // difference with SerialSubscription + Assert.assertFalse(s1.isUnsubscribed) multiple.unsubscribe() - assertTrue(multiple.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertTrue(s1.isUnsubscribed) + Assert.assertTrue(multiple.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) + Assert.assertTrue(s1.isUnsubscribed) val s2 = Subscription() - assertFalse(s2.isUnsubscribed) + Assert.assertFalse(s2.isUnsubscribed) multiple.subscription = s2 - assertTrue(s2.isUnsubscribed) - assertFalse(s0.isUnsubscribed) + Assert.assertTrue(s2.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) } @Test @@ -120,25 +120,25 @@ class SubscriptionTests extends JUnitSuite { val s1 = Subscription() val serial = SerialSubscription() - assertFalse(serial.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) + Assert.assertFalse(serial.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) + Assert.assertFalse(s1.isUnsubscribed) serial.subscription = s0 - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) + Assert.assertFalse(s0.isUnsubscribed) + Assert.assertFalse(s1.isUnsubscribed) serial.subscription = s1 - assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription - assertFalse(s1.isUnsubscribed) + Assert.assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription + Assert.assertFalse(s1.isUnsubscribed) serial.unsubscribe() - assertTrue(serial.isUnsubscribed) - assertTrue(s1.isUnsubscribed) + Assert.assertTrue(serial.isUnsubscribed) + Assert.assertTrue(s1.isUnsubscribed) val s2 = Subscription() - assertFalse(s2.isUnsubscribed) + Assert.assertFalse(s2.isUnsubscribed) serial.subscription = s2 - assertTrue(s2.isUnsubscribed) + Assert.assertTrue(s2.isUnsubscribed) } } From ea43e6dbd7067a45f857e11d46090f9ce96c33b6 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 10:55:28 -0800 Subject: [PATCH 031/441] Re-instantiating commented out tests. --- .../rx/lang/scala/CompletenessTest.scala | 708 +++++++++--------- 1 file changed, 354 insertions(+), 354 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala index 4875aa50c2..41bbdca347 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala @@ -1,354 +1,354 @@ -//package rx.lang.scala -// -//import java.util.Calendar -// -//import scala.collection.SortedMap -//import scala.reflect.runtime.universe -//import scala.reflect.runtime.universe.Symbol -//import scala.reflect.runtime.universe.Type -//import scala.reflect.runtime.universe.typeOf -// -//import org.junit.Ignore -//import org.junit.Test -//import org.scalatest.junit.JUnitSuite -// -///** -// * These tests can be used to check if all methods of the Java Observable have a corresponding -// * method in the Scala Observable. -// * -// * These tests don't contain any assertions, so they will always succeed, but they print their -// * results to stdout. -// */ -//class CompletenessTest extends JUnitSuite { -// -// // some frequently used comments: -// val unnecessary = "[considered unnecessary in Scala land]" -// val deprecated = "[deprecated in RxJava]" -// val averageProblem = "[We can't have a general average method because Scala's `Numeric` does not have " + -// "scalar multiplication (we would need to calculate `(1.0/numberOfElements)*sum`). " + -// "You can use `fold` instead to accumulate `sum` and `numberOfElements` and divide at the end.]" -// val commentForFirstWithPredicate = "[use `.filter(condition).first`]" -// val fromFuture = "[TODO: Decide how Scala Futures should relate to Observables. Should there be a " + -// "common base interface for Future and Observable? And should Futures also have an unsubscribe method?]" -// -// /** -// * Maps each method from the Java Observable to its corresponding method in the Scala Observable -// */ -// val correspondence = defaultMethodCorrespondence ++ correspondenceChanges // ++ overrides LHS with RHS -// -// /** -// * Creates default method correspondence mappings, assuming that Scala methods have the same -// * name and the same argument types as in Java -// */ -// def defaultMethodCorrespondence: Map[String, String] = { -// val allMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.Observable[_]]) -// val tuples = for (javaM <- allMethods) yield (javaM, javaMethodSignatureToScala(javaM)) -// tuples.toMap -// } -// -// /** -// * Manually added mappings from Java Observable methods to Scala Observable methods -// */ -// def correspondenceChanges = Map( -// // manually added entries for Java instance methods -// "aggregate(Func2[T, T, T])" -> "reduce((U, U) => U)", -// "aggregate(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", -// "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)", -// "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)", -// "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)", -// "count()" -> "length", -// "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])", -// "elementAt(Int)" -> "[use `.drop(index).first`]", -// "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]", -// "first(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, -// "firstOrDefault(T)" -> "firstOrElse(=> U)", -// "firstOrDefault(Func1[_ >: T, Boolean], T)" -> "[use `.filter(condition).firstOrElse(default)`]", -// "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]", -// "mapMany(Func1[_ >: T, _ <: Observable[_ <: R]])" -> "flatMap(T => Observable[R])", -// "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]", -// "onErrorResumeNext(Func1[Throwable, _ <: Observable[_ <: T]])" -> "onErrorResumeNext(Throwable => Observable[U])", -// "onErrorResumeNext(Observable[_ <: T])" -> "onErrorResumeNext(Observable[U])", -// "onErrorReturn(Func1[Throwable, _ <: T])" -> "onErrorReturn(Throwable => U)", -// "onExceptionResumeNext(Observable[_ <: T])" -> "onExceptionResumeNext(Observable[U])", -// "parallel(Func1[Observable[T], Observable[R]])" -> "parallel(Observable[T] => Observable[R])", -// "parallel(Func1[Observable[T], Observable[R]], Scheduler)" -> "parallel(Observable[T] => Observable[R], Scheduler)", -// "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)", -// "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", -// "scan(Func2[T, T, T])" -> unnecessary, -// "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)", -// "skip(Int)" -> "drop(Int)", -// "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)", -// "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary, -// "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]", -// "takeFirst()" -> "first", -// "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, -// "takeLast(Int)" -> "takeRight(Int)", -// "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]", -// "toList()" -> "toSeq", -// "toSortedList()" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sorted)`]", -// "toSortedList(Func2[_ >: T, _ >: T, Integer])" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sortWith(f))`]", -// "where(Func1[_ >: T, Boolean])" -> "filter(T => Boolean)", -// "window(Long, Long, TimeUnit)" -> "window(Duration, Duration)", -// "window(Long, Long, TimeUnit, Scheduler)" -> "window(Duration, Duration, Scheduler)", -// -// // manually added entries for Java static methods -// "average(Observable[Integer])" -> averageProblem, -// "averageDoubles(Observable[Double])" -> averageProblem, -// "averageFloats(Observable[Float])" -> averageProblem, -// "averageLongs(Observable[Long])" -> averageProblem, -// "create(OnSubscribeFunc[T])" -> "apply(Observer[T] => Subscription)", -// "combineLatest(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "combineLatest(Observable[U])", -// "concat(Observable[_ <: Observable[_ <: T]])" -> "concat(<:<[Observable[T], Observable[Observable[U]]])", -// "defer(Func0[_ <: Observable[_ <: T]])" -> "defer(=> Observable[T])", -// "empty()" -> "apply(T*)", -// "error(Throwable)" -> "apply(Throwable)", -// "from(Array[T])" -> "apply(T*)", -// "from(Iterable[_ <: T])" -> "apply(T*)", -// "from(Future[_ <: T])" -> fromFuture, -// "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture, -// "from(Future[_ <: T], Scheduler)" -> fromFuture, -// "just(T)" -> "apply(T*)", -// "merge(Observable[_ <: T], Observable[_ <: T])" -> "merge(Observable[U])", -// "merge(Observable[_ <: Observable[_ <: T]])" -> "flatten(<:<[Observable[T], Observable[Observable[U]]])", -// "mergeDelayError(Observable[_ <: T], Observable[_ <: T])" -> "mergeDelayError(Observable[U])", -// "mergeDelayError(Observable[_ <: Observable[_ <: T]])" -> "flattenDelayError(<:<[Observable[T], Observable[Observable[U]]])", -// "range(Int, Int)" -> "apply(Range)", -// "sequenceEqual(Observable[_ <: T], Observable[_ <: T])" -> "[use `(first zip second) map (p => p._1 == p._2)`]", -// "sequenceEqual(Observable[_ <: T], Observable[_ <: T], Func2[_ >: T, _ >: T, Boolean])" -> "[use `(first zip second) map (p => equality(p._1, p._2))`]", -// "sum(Observable[Integer])" -> "sum(Numeric[U])", -// "sumDoubles(Observable[Double])" -> "sum(Numeric[U])", -// "sumFloats(Observable[Float])" -> "sum(Numeric[U])", -// "sumLongs(Observable[Long])" -> "sum(Numeric[U])", -// "synchronize(Observable[T])" -> "synchronize", -// "switchDo(Observable[_ <: Observable[_ <: T]])" -> deprecated, -// "switchOnNext(Observable[_ <: Observable[_ <: T]])" -> "switch(<:<[Observable[T], Observable[Observable[U]]])", -// "zip(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "[use instance method `zip` and `map`]", -// "zip(Observable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]", -// "zip(Iterable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]" -// ) ++ List.iterate("T", 9)(s => s + ", T").map( -// // all 9 overloads of startWith: -// "startWith(" + _ + ")" -> "[unnecessary because we can just use `++` instead]" -// ).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( -// // concat 2-9 -// "concat(" + _ + ")" -> "[unnecessary because we can use `++` instead or `Observable(o1, o2, ...).concat`]" -// ).drop(1).toMap ++ List.iterate("T", 10)(s => s + ", T").map( -// // all 10 overloads of from: -// "from(" + _ + ")" -> "apply(T*)" -// ).toMap ++ (3 to 9).map(i => { -// // zip3-9: -// val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") -// val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") -// ("zip(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", unnecessary) -// }).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( -// // merge 3-9: -// "merge(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flatten` instead]" -// ).drop(2).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( -// // mergeDelayError 3-9: -// "mergeDelayError(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flattenDelayError` instead]" -// ).drop(2).toMap ++ (3 to 9).map(i => { -// // combineLatest 3-9: -// val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") -// val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") -// ("combineLatest(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", "[If C# doesn't need it, Scala doesn't need it either ;-)]") -// }).toMap -// -// def removePackage(s: String) = s.replaceAll("(\\w+\\.)+(\\w+)", "$2") -// -// def methodMembersToMethodStrings(members: Iterable[Symbol]): Iterable[String] = { -// for (member <- members; alt <- member.asTerm.alternatives) yield { -// val m = alt.asMethod -// // multiple parameter lists in case of curried functions -// val paramListStrs = for (paramList <- m.paramss) yield { -// paramList.map( -// symb => removePackage(symb.typeSignature.toString.replaceAll(",(\\S)", ", $1")) -// ).mkString("(", ", ", ")") -// } -// val name = alt.asMethod.name.decoded -// name + paramListStrs.mkString("") -// } -// } -// -// def getPublicInstanceMethods(tp: Type): Iterable[String] = { -// // declarations: => only those declared in Observable -// // members => also those of superclasses -// methodMembersToMethodStrings(tp.declarations.filter(m => m.isMethod && m.isPublic)) -// // TODO how can we filter out instance methods which were put into companion because -// // of extends AnyVal in a way which does not depend on implementation-chosen name '$extension'? -// .filter(! _.contains("$extension")) -// } -// -// // also applicable for Java types -// def getPublicInstanceAndCompanionMethods(tp: Type): Iterable[String] = -// getPublicInstanceMethods(tp) ++ -// getPublicInstanceMethods(tp.typeSymbol.companionSymbol.typeSignature) -// -// def printMethodSet(title: String, tp: Type) { -// println("\n" + title) -// println(title.map(_ => '-') + "\n") -// getPublicInstanceMethods(tp).toList.sorted.foreach(println(_)) -// } -// -// @Ignore // because spams output -// @Test def printJavaInstanceMethods(): Unit = { -// printMethodSet("Instance methods of rx.Observable", -// typeOf[rx.Observable[_]]) -// } -// -// @Ignore // because spams output -// @Test def printScalaInstanceMethods(): Unit = { -// printMethodSet("Instance methods of rx.lang.scala.Observable", -// typeOf[rx.lang.scala.Observable[_]]) -// } -// -// @Ignore // because spams output -// @Test def printJavaStaticMethods(): Unit = { -// printMethodSet("Static methods of rx.Observable", -// typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature) -// } -// -// @Ignore // because spams output -// @Test def printScalaCompanionMethods(): Unit = { -// printMethodSet("Companion methods of rx.lang.scala.Observable", -// typeOf[rx.lang.scala.Observable.type]) -// } -// -// def javaMethodSignatureToScala(s: String): String = { -// s.replaceAllLiterally("Long, TimeUnit", "Duration") -// .replaceAll("Action0", "() => Unit") -// // nested [] can't be parsed with regex, so these will have to be added manually -// .replaceAll("Action1\\[([^]]*)\\]", "$1 => Unit") -// .replaceAll("Action2\\[([^]]*), ([^]]*)\\]", "($1, $2) => Unit") -// .replaceAll("Func0\\[([^]]*)\\]", "() => $1") -// .replaceAll("Func1\\[([^]]*), ([^]]*)\\]", "$1 => $2") -// .replaceAll("Func2\\[([^]]*), ([^]]*), ([^]]*)\\]", "($1, $2) => $3") -// .replaceAllLiterally("_ <: ", "") -// .replaceAllLiterally("_ >: ", "") -// .replaceAll("(\\w+)\\(\\)", "$1") -// } -// -// @Ignore // because spams output -// @Test def printDefaultMethodCorrespondence(): Unit = { -// println("\nDefault Method Correspondence") -// println( "-----------------------------\n") -// val c = SortedMap(defaultMethodCorrespondence.toSeq : _*) -// val len = c.keys.map(_.length).max + 2 -// for ((javaM, scalaM) <- c) { -// println(s""" %-${len}s -> %s,""".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) -// } -// } -// -// @Ignore // because spams output -// @Test def printCorrectedMethodCorrespondence(): Unit = { -// println("\nCorrected Method Correspondence") -// println( "-------------------------------\n") -// val c = SortedMap(correspondence.toSeq : _*) -// for ((javaM, scalaM) <- c) { -// println("%s -> %s,".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) -// } -// } -// -// def checkMethodPresence(expectedMethods: Iterable[String], tp: Type): Unit = { -// val actualMethods = getPublicInstanceAndCompanionMethods(tp).toSet -// val expMethodsSorted = expectedMethods.toList.sorted -// var good = 0 -// var bad = 0 -// for (m <- expMethodsSorted) if (actualMethods.contains(m) || m.charAt(0) == '[') { -// good += 1 -// } else { -// bad += 1 -// println(s"Warning: $m is NOT present in $tp") -// } -// val status = if (bad == 0) "SUCCESS" else "BAD" -// println(s"$status: $bad out of ${bad+good} methods were not found in $tp") -// } -// -// @Test def checkScalaMethodPresenceVerbose(): Unit = { -// println("\nTesting that all mentioned Scala methods exist") -// println( "----------------------------------------------\n") -// -// val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet -// var good = 0 -// var bad = 0 -// for ((javaM, scalaM) <- SortedMap(correspondence.toSeq :_*)) { -// if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') { -// good += 1 -// } else { -// bad += 1 -// println(s"Warning:") -// println(s"$scalaM is NOT present in Scala Observable") -// println(s"$javaM is the method in Java Observable generating this warning") -// } -// } -// val status = if (bad == 0) "SUCCESS" else "BAD" -// println(s"\n$status: $bad out of ${bad+good} methods were not found in Scala Observable") -// } -// -// def setTodoForMissingMethods(corresp: Map[String, String]): Map[String, String] = { -// val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet -// for ((javaM, scalaM) <- corresp) yield -// (javaM, if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') scalaM else "[**TODO: missing**]") -// } -// -// @Test def checkJavaMethodPresence(): Unit = { -// println("\nTesting that all mentioned Java methods exist") -// println( "---------------------------------------------\n") -// checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]]) -// } -// -// @Ignore // because we prefer the verbose version -// @Test def checkScalaMethodPresence(): Unit = { -// checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]]) -// } -// -// def scalaToJavaSignature(s: String) = -// s.replaceAllLiterally("_ <:", "? extends") -// .replaceAllLiterally("_ >:", "? super") -// .replaceAllLiterally("[", "<") -// .replaceAllLiterally("]", ">") -// .replaceAllLiterally("Array", "T[]") -// -// def escapeJava(s: String) = -// s.replaceAllLiterally("<", "<") -// .replaceAllLiterally(">", ">") -// -// @Ignore // because spams output -// @Test def printMarkdownCorrespondenceTable() { -// def isInteresting(p: (String, String)): Boolean = -// p._1.replaceAllLiterally("()", "") != p._2 -// def groupingKey(p: (String, String)): (String, String) = -// (if (p._1.startsWith("average")) "average" else p._1.takeWhile(_ != '('), p._2) -// def formatJavaCol(name: String, alternatives: Iterable[String]): String = { -// alternatives.toList.sorted.map(scalaToJavaSignature(_)).map(s => { -// if (s.length > 64) { -// val toolTip = escapeJava(s) -// "" + name + "(...)" -// } else { -// "`" + s + "`" -// } -// }).mkString("
") -// } -// def formatScalaCol(s: String): String = -// if (s.startsWith("[") && s.endsWith("]")) s.drop(1).dropRight(1) else "`" + s + "`" -// def escape(s: String) = s.replaceAllLiterally("[", "<").replaceAllLiterally("]", ">") -// -// println(""" -//## Comparison of Scala Observable and Java Observable -// -//Note: -//* This table contains both static methods and instance methods. -//* If a signature is too long, move your mouse over it to get the full signature. -// -// -//| Java Method | Scala Method | -//|-------------|--------------|""") -// -// val ps = setTodoForMissingMethods(correspondence) -// -// (for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield { -// "| " + formatJavaCol(javaName, pairs.map(_._1)) + " | " + formatScalaCol(scalaCol) + " |" -// }).foreach(println(_)) -// println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.") -// println(s"**Do not edit**. Instead, edit `${getClass.getCanonicalName}`.") -// } -// -//} +package rx.lang.scala + +import java.util.Calendar + +import scala.collection.SortedMap +import scala.reflect.runtime.universe +import scala.reflect.runtime.universe.Symbol +import scala.reflect.runtime.universe.Type +import scala.reflect.runtime.universe.typeOf + +import org.junit.Ignore +import org.junit.Test +import org.scalatest.junit.JUnitSuite + +/** + * These tests can be used to check if all methods of the Java Observable have a corresponding + * method in the Scala Observable. + * + * These tests don't contain any assertions, so they will always succeed, but they print their + * results to stdout. + */ +class CompletenessTest extends JUnitSuite { + + // some frequently used comments: + val unnecessary = "[considered unnecessary in Scala land]" + val deprecated = "[deprecated in RxJava]" + val averageProblem = "[We can't have a general average method because Scala's `Numeric` does not have " + + "scalar multiplication (we would need to calculate `(1.0/numberOfElements)*sum`). " + + "You can use `fold` instead to accumulate `sum` and `numberOfElements` and divide at the end.]" + val commentForFirstWithPredicate = "[use `.filter(condition).first`]" + val fromFuture = "[TODO: Decide how Scala Futures should relate to Observables. Should there be a " + + "common base interface for Future and Observable? And should Futures also have an unsubscribe method?]" + + /** + * Maps each method from the Java Observable to its corresponding method in the Scala Observable + */ + val correspondence = defaultMethodCorrespondence ++ correspondenceChanges // ++ overrides LHS with RHS + + /** + * Creates default method correspondence mappings, assuming that Scala methods have the same + * name and the same argument types as in Java + */ + def defaultMethodCorrespondence: Map[String, String] = { + val allMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.Observable[_]]) + val tuples = for (javaM <- allMethods) yield (javaM, javaMethodSignatureToScala(javaM)) + tuples.toMap + } + + /** + * Manually added mappings from Java Observable methods to Scala Observable methods + */ + def correspondenceChanges = Map( + // manually added entries for Java instance methods + "aggregate(Func2[T, T, T])" -> "reduce((U, U) => U)", + "aggregate(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", + "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)", + "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)", + "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)", + "count()" -> "length", + "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])", + "elementAt(Int)" -> "[use `.drop(index).first`]", + "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]", + "first(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, + "firstOrDefault(T)" -> "firstOrElse(=> U)", + "firstOrDefault(Func1[_ >: T, Boolean], T)" -> "[use `.filter(condition).firstOrElse(default)`]", + "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]", + "mapMany(Func1[_ >: T, _ <: Observable[_ <: R]])" -> "flatMap(T => Observable[R])", + "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]", + "onErrorResumeNext(Func1[Throwable, _ <: Observable[_ <: T]])" -> "onErrorResumeNext(Throwable => Observable[U])", + "onErrorResumeNext(Observable[_ <: T])" -> "onErrorResumeNext(Observable[U])", + "onErrorReturn(Func1[Throwable, _ <: T])" -> "onErrorReturn(Throwable => U)", + "onExceptionResumeNext(Observable[_ <: T])" -> "onExceptionResumeNext(Observable[U])", + "parallel(Func1[Observable[T], Observable[R]])" -> "parallel(Observable[T] => Observable[R])", + "parallel(Func1[Observable[T], Observable[R]], Scheduler)" -> "parallel(Observable[T] => Observable[R], Scheduler)", + "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)", + "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)", + "scan(Func2[T, T, T])" -> unnecessary, + "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)", + "skip(Int)" -> "drop(Int)", + "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)", + "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary, + "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]", + "takeFirst()" -> "first", + "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate, + "takeLast(Int)" -> "takeRight(Int)", + "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]", + "toList()" -> "toSeq", + "toSortedList()" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sorted)`]", + "toSortedList(Func2[_ >: T, _ >: T, Integer])" -> "[Sorting is already done in Scala's collection library, use `.toSeq.map(_.sortWith(f))`]", + "where(Func1[_ >: T, Boolean])" -> "filter(T => Boolean)", + "window(Long, Long, TimeUnit)" -> "window(Duration, Duration)", + "window(Long, Long, TimeUnit, Scheduler)" -> "window(Duration, Duration, Scheduler)", + + // manually added entries for Java static methods + "average(Observable[Integer])" -> averageProblem, + "averageDoubles(Observable[Double])" -> averageProblem, + "averageFloats(Observable[Float])" -> averageProblem, + "averageLongs(Observable[Long])" -> averageProblem, + "create(OnSubscribeFunc[T])" -> "apply(Observer[T] => Subscription)", + "combineLatest(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "combineLatest(Observable[U])", + "concat(Observable[_ <: Observable[_ <: T]])" -> "concat(<:<[Observable[T], Observable[Observable[U]]])", + "defer(Func0[_ <: Observable[_ <: T]])" -> "defer(=> Observable[T])", + "empty()" -> "apply(T*)", + "error(Throwable)" -> "apply(Throwable)", + "from(Array[T])" -> "apply(T*)", + "from(Iterable[_ <: T])" -> "apply(T*)", + "from(Future[_ <: T])" -> fromFuture, + "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture, + "from(Future[_ <: T], Scheduler)" -> fromFuture, + "just(T)" -> "apply(T*)", + "merge(Observable[_ <: T], Observable[_ <: T])" -> "merge(Observable[U])", + "merge(Observable[_ <: Observable[_ <: T]])" -> "flatten(<:<[Observable[T], Observable[Observable[U]]])", + "mergeDelayError(Observable[_ <: T], Observable[_ <: T])" -> "mergeDelayError(Observable[U])", + "mergeDelayError(Observable[_ <: Observable[_ <: T]])" -> "flattenDelayError(<:<[Observable[T], Observable[Observable[U]]])", + "range(Int, Int)" -> "apply(Range)", + "sequenceEqual(Observable[_ <: T], Observable[_ <: T])" -> "[use `(first zip second) map (p => p._1 == p._2)`]", + "sequenceEqual(Observable[_ <: T], Observable[_ <: T], Func2[_ >: T, _ >: T, Boolean])" -> "[use `(first zip second) map (p => equality(p._1, p._2))`]", + "sum(Observable[Integer])" -> "sum(Numeric[U])", + "sumDoubles(Observable[Double])" -> "sum(Numeric[U])", + "sumFloats(Observable[Float])" -> "sum(Numeric[U])", + "sumLongs(Observable[Long])" -> "sum(Numeric[U])", + "synchronize(Observable[T])" -> "synchronize", + "switchDo(Observable[_ <: Observable[_ <: T]])" -> deprecated, + "switchOnNext(Observable[_ <: Observable[_ <: T]])" -> "switch(<:<[Observable[T], Observable[Observable[U]]])", + "zip(Observable[_ <: T1], Observable[_ <: T2], Func2[_ >: T1, _ >: T2, _ <: R])" -> "[use instance method `zip` and `map`]", + "zip(Observable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]", + "zip(Iterable[_ <: Observable[_]], FuncN[_ <: R])" -> "[use `zip` in companion object and `map`]" + ) ++ List.iterate("T", 9)(s => s + ", T").map( + // all 9 overloads of startWith: + "startWith(" + _ + ")" -> "[unnecessary because we can just use `++` instead]" + ).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( + // concat 2-9 + "concat(" + _ + ")" -> "[unnecessary because we can use `++` instead or `Observable(o1, o2, ...).concat`]" + ).drop(1).toMap ++ List.iterate("T", 10)(s => s + ", T").map( + // all 10 overloads of from: + "from(" + _ + ")" -> "apply(T*)" + ).toMap ++ (3 to 9).map(i => { + // zip3-9: + val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") + val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") + ("zip(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", unnecessary) + }).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( + // merge 3-9: + "merge(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flatten` instead]" + ).drop(2).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map( + // mergeDelayError 3-9: + "mergeDelayError(" + _ + ")" -> "[unnecessary because we can use `Observable(o1, o2, ...).flattenDelayError` instead]" + ).drop(2).toMap ++ (3 to 9).map(i => { + // combineLatest 3-9: + val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("") + val funcParams = (1 to i).map(j => s"_ >: T$j, ").mkString("") + ("combineLatest(" + obsArgs + "Func" + i + "[" + funcParams + "_ <: R])", "[If C# doesn't need it, Scala doesn't need it either ;-)]") + }).toMap + + def removePackage(s: String) = s.replaceAll("(\\w+\\.)+(\\w+)", "$2") + + def methodMembersToMethodStrings(members: Iterable[Symbol]): Iterable[String] = { + for (member <- members; alt <- member.asTerm.alternatives) yield { + val m = alt.asMethod + // multiple parameter lists in case of curried functions + val paramListStrs = for (paramList <- m.paramss) yield { + paramList.map( + symb => removePackage(symb.typeSignature.toString.replaceAll(",(\\S)", ", $1")) + ).mkString("(", ", ", ")") + } + val name = alt.asMethod.name.decoded + name + paramListStrs.mkString("") + } + } + + def getPublicInstanceMethods(tp: Type): Iterable[String] = { + // declarations: => only those declared in Observable + // members => also those of superclasses + methodMembersToMethodStrings(tp.declarations.filter(m => m.isMethod && m.isPublic)) + // TODO how can we filter out instance methods which were put into companion because + // of extends AnyVal in a way which does not depend on implementation-chosen name '$extension'? + .filter(! _.contains("$extension")) + } + + // also applicable for Java types + def getPublicInstanceAndCompanionMethods(tp: Type): Iterable[String] = + getPublicInstanceMethods(tp) ++ + getPublicInstanceMethods(tp.typeSymbol.companionSymbol.typeSignature) + + def printMethodSet(title: String, tp: Type) { + println("\n" + title) + println(title.map(_ => '-') + "\n") + getPublicInstanceMethods(tp).toList.sorted.foreach(println(_)) + } + + @Ignore // because spams output + @Test def printJavaInstanceMethods(): Unit = { + printMethodSet("Instance methods of rx.Observable", + typeOf[rx.Observable[_]]) + } + + @Ignore // because spams output + @Test def printScalaInstanceMethods(): Unit = { + printMethodSet("Instance methods of rx.lang.scala.Observable", + typeOf[rx.lang.scala.Observable[_]]) + } + + @Ignore // because spams output + @Test def printJavaStaticMethods(): Unit = { + printMethodSet("Static methods of rx.Observable", + typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature) + } + + @Ignore // because spams output + @Test def printScalaCompanionMethods(): Unit = { + printMethodSet("Companion methods of rx.lang.scala.Observable", + typeOf[rx.lang.scala.Observable.type]) + } + + def javaMethodSignatureToScala(s: String): String = { + s.replaceAllLiterally("Long, TimeUnit", "Duration") + .replaceAll("Action0", "() => Unit") + // nested [] can't be parsed with regex, so these will have to be added manually + .replaceAll("Action1\\[([^]]*)\\]", "$1 => Unit") + .replaceAll("Action2\\[([^]]*), ([^]]*)\\]", "($1, $2) => Unit") + .replaceAll("Func0\\[([^]]*)\\]", "() => $1") + .replaceAll("Func1\\[([^]]*), ([^]]*)\\]", "$1 => $2") + .replaceAll("Func2\\[([^]]*), ([^]]*), ([^]]*)\\]", "($1, $2) => $3") + .replaceAllLiterally("_ <: ", "") + .replaceAllLiterally("_ >: ", "") + .replaceAll("(\\w+)\\(\\)", "$1") + } + + @Ignore // because spams output + @Test def printDefaultMethodCorrespondence(): Unit = { + println("\nDefault Method Correspondence") + println( "-----------------------------\n") + val c = SortedMap(defaultMethodCorrespondence.toSeq : _*) + val len = c.keys.map(_.length).max + 2 + for ((javaM, scalaM) <- c) { + println(s""" %-${len}s -> %s,""".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) + } + } + + @Ignore // because spams output + @Test def printCorrectedMethodCorrespondence(): Unit = { + println("\nCorrected Method Correspondence") + println( "-------------------------------\n") + val c = SortedMap(correspondence.toSeq : _*) + for ((javaM, scalaM) <- c) { + println("%s -> %s,".format("\"" + javaM + "\"", "\"" + scalaM + "\"")) + } + } + + def checkMethodPresence(expectedMethods: Iterable[String], tp: Type): Unit = { + val actualMethods = getPublicInstanceAndCompanionMethods(tp).toSet + val expMethodsSorted = expectedMethods.toList.sorted + var good = 0 + var bad = 0 + for (m <- expMethodsSorted) if (actualMethods.contains(m) || m.charAt(0) == '[') { + good += 1 + } else { + bad += 1 + println(s"Warning: $m is NOT present in $tp") + } + val status = if (bad == 0) "SUCCESS" else "BAD" + println(s"$status: $bad out of ${bad+good} methods were not found in $tp") + } + + @Test def checkScalaMethodPresenceVerbose(): Unit = { + println("\nTesting that all mentioned Scala methods exist") + println( "----------------------------------------------\n") + + val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet + var good = 0 + var bad = 0 + for ((javaM, scalaM) <- SortedMap(correspondence.toSeq :_*)) { + if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') { + good += 1 + } else { + bad += 1 + println(s"Warning:") + println(s"$scalaM is NOT present in Scala Observable") + println(s"$javaM is the method in Java Observable generating this warning") + } + } + val status = if (bad == 0) "SUCCESS" else "BAD" + println(s"\n$status: $bad out of ${bad+good} methods were not found in Scala Observable") + } + + def setTodoForMissingMethods(corresp: Map[String, String]): Map[String, String] = { + val actualMethods = getPublicInstanceAndCompanionMethods(typeOf[rx.lang.scala.Observable[_]]).toSet + for ((javaM, scalaM) <- corresp) yield + (javaM, if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') scalaM else "[**TODO: missing**]") + } + + @Test def checkJavaMethodPresence(): Unit = { + println("\nTesting that all mentioned Java methods exist") + println( "---------------------------------------------\n") + checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]]) + } + + @Ignore // because we prefer the verbose version + @Test def checkScalaMethodPresence(): Unit = { + checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]]) + } + + def scalaToJavaSignature(s: String) = + s.replaceAllLiterally("_ <:", "? extends") + .replaceAllLiterally("_ >:", "? super") + .replaceAllLiterally("[", "<") + .replaceAllLiterally("]", ">") + .replaceAllLiterally("Array", "T[]") + + def escapeJava(s: String) = + s.replaceAllLiterally("<", "<") + .replaceAllLiterally(">", ">") + + @Ignore // because spams output + @Test def printMarkdownCorrespondenceTable() { + def isInteresting(p: (String, String)): Boolean = + p._1.replaceAllLiterally("()", "") != p._2 + def groupingKey(p: (String, String)): (String, String) = + (if (p._1.startsWith("average")) "average" else p._1.takeWhile(_ != '('), p._2) + def formatJavaCol(name: String, alternatives: Iterable[String]): String = { + alternatives.toList.sorted.map(scalaToJavaSignature(_)).map(s => { + if (s.length > 64) { + val toolTip = escapeJava(s) + "" + name + "(...)" + } else { + "`" + s + "`" + } + }).mkString("
") + } + def formatScalaCol(s: String): String = + if (s.startsWith("[") && s.endsWith("]")) s.drop(1).dropRight(1) else "`" + s + "`" + def escape(s: String) = s.replaceAllLiterally("[", "<").replaceAllLiterally("]", ">") + + println(""" +## Comparison of Scala Observable and Java Observable + +Note: +* This table contains both static methods and instance methods. +* If a signature is too long, move your mouse over it to get the full signature. + + +| Java Method | Scala Method | +|-------------|--------------|""") + + val ps = setTodoForMissingMethods(correspondence) + + (for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield { + "| " + formatJavaCol(javaName, pairs.map(_._1)) + " | " + formatScalaCol(scalaCol) + " |" + }).foreach(println(_)) + println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.") + println(s"**Do not edit**. Instead, edit `${getClass.getCanonicalName}`.") + } + +} From ab34d6a26d3bfc11daa9aa3132b477bf9e278b01 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 11:01:16 -0800 Subject: [PATCH 032/441] Changed def to val in release notes to match source code. Which I could put in hyperlink ;-) --- language-adaptors/rxjava-scala/ReleaseNotes.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 3608e8c026..4a3d222b72 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -52,7 +52,7 @@ Again, while *technically* this is a breaking change, this should not have any i ```scala trait Observable[+T] { - private [scala] def asJavaObservable: rx.Observable[_ <: T] + private [scala] val asJavaObservable: rx.Observable[_ <: T] } object Observable { @@ -108,7 +108,7 @@ The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.l ```scala trait Scheduler { - private[scala] def asJavaScheduler: rx.Scheduler; + private[scala] val asJavaScheduler: rx.Scheduler; } private [scala] object Scheduler {...} @@ -177,7 +177,7 @@ objects of `Notification` now have both constructor (`apply`) and extractor (`un ```scala object Notification {...} trait Notification[+T] { - private [scala] def asJavaNotification: rx.Notification[_ <: T] + private [scala] val asJavaNotification: rx.Notification[_ <: T] } object Notification { @@ -186,7 +186,9 @@ object Notification { object OnCompleted { def apply(...){}; def unapply(...){...} } } ``` -To construct a `Notification`, you import `rx.lang.scala.Notification._` and use `OnNext("hello")`, or `OnError(new Exception("Oops!"))`, or `OnCompleted()`. +To construct a `Notification`, you import `rx.lang.scala.Notification._` and use `OnNext("hello")`, +or `OnError(new Exception("Oops!"))`, or `OnCompleted()`. + To pattern match on a notification you can create a partial function like so: `case OnNext(v) => { ... v ... }`. There are no breaking changes for notifications. From 51c48776d868bbc6a6bc4ce4f0137dc3215283f2 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 11:22:32 -0800 Subject: [PATCH 033/441] Doc comments for Notification. --- .../scala/rx/lang/scala/Notification.scala | 40 ++++++++++++++++--- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index 9c108350d7..106c959684 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -29,9 +29,9 @@ sealed trait Notification[+T] { * {{{ * import Notification._ * Observable(1, 2, 3).materialize.subscribe(n => n match { - * case OnNext(v) => println("Got value " + v) + * case OnNext(v) => println("Got value " + v) * case OnCompleted() => println("Completed") - * case OnError(err) => println("Error: " + err.getMessage) + * case OnError(err) => println("Error: " + err.getMessage) * }) * }}} */ @@ -45,15 +45,25 @@ object Notification { // OnNext, OnError, OnCompleted are not case classes because we don't want pattern matching // to extract the rx.Notification - - - object OnNext { + /** + * Constructor for onNext notifications. + * + * @param value + * The item passed to the onNext method. + */ def apply[T](value: T): Notification[T] = { Notification(new rx.Notification[T](value)) } + /** + * Destructor for oNNext notifications. + * @param notification + * The [[rx.lang.scala.Notification]] to be destructed. + * @return + * The item contained in this notification. + */ def unapply[U](notification: Notification[U]): Option[U] = notification match { case onNext: OnNext[U] => Some(onNext.value) case _ => None @@ -66,10 +76,24 @@ object Notification { object OnError { + /** + * Constructor for onError notifications. + * + * @param error + * The exception passed to the onNext method. + */ def apply[T](error: Throwable): Notification[T] = { Notification(new rx.Notification[T](error)) } + /** + * Destructor for onError notifications. + * + * @param notification + * The [[rx.lang.scala.Notification]] to be deconstructed + * @return + * The [[java.lang.Throwable]] value contained in this notification. + */ def unapply[U](notification: Notification[U]): Option[Throwable] = notification match { case onError: OnError[U] => Some(onError.error) case _ => None @@ -82,10 +106,16 @@ object Notification { object OnCompleted { + /** + * Constructor for onCompleted notifications. + */ def apply[T](): Notification[T] = { Notification(new rx.Notification()) } + /** + * Destructor for onCompleted notifications. + */ def unapply[U](notification: Notification[U]): Option[Unit] = notification match { case onCompleted: OnCompleted[U] => Some() case _ => None From 35d200d1fd54099aad5d7067c3bddbf5b30b08c8 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 12:17:40 -0800 Subject: [PATCH 034/441] Notification tests. --- .../scala/rx/lang/scala/Notification.scala | 18 ++++++++++++++++ .../rx/lang/scala/NotificationTests.scala | 21 +++++++++++++++++++ .../rx/lang/scala/SubscriptionTests.scala | 2 ++ 3 files changed, 41 insertions(+) create mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index 106c959684..02174f41f5 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -20,6 +20,24 @@ package rx.lang.scala */ sealed trait Notification[+T] { private [scala] val asJava: rx.Notification[_ <: T] + + /** + * Invokes the function corresponding to the notification. + * + * @param onNext + * The function to invoke for an [[rx.lang.scala.Notification.OnNext]] notification. + * @param onError + * The function to invoke for an [[rx.lang.scala.Notification.OnError]] notification. + * @param onCompleted + * The function to invoke for an [[rx.lang.scala.Notification.OnCompleted]] notification. + */ + def accept[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = { + this match { + case Notification.OnNext(value) => onNext(value) + case Notification.OnError(error) => onError(error) + case Notification.OnCompleted() => onCompleted() + } + } } /** diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala new file mode 100644 index 0000000000..12f8ad3dda --- /dev/null +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala @@ -0,0 +1,21 @@ +package rx.lang.scala + + +import org.junit.{Assert, Test} +import org.junit.Assert +import org.scalatest.junit.JUnitSuite +import scala.concurrent.duration._ +import scala.language.postfixOps +import org.mockito.Mockito._ +import org.mockito.Matchers._ +import rx.lang.scala.Notification.{OnError, OnNext} + + +class NotificationTests extends JUnitSuite { + @Test + def creation() { + + val onNext = OnNext(42) + Assert.assertEquals(42, onNext match { case OnNext(value) => value }) + } +} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index 6612a1351c..cf8aa415a6 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -10,6 +10,8 @@ import org.mockito.Mockito._ import org.mockito.Matchers._ import rx.lang.scala.subscriptions.{SerialSubscription, MultipleAssignmentSubscription, CompositeSubscription} + + class SubscriptionTests extends JUnitSuite { @Test def subscriptionCreate() { From 168279e0956489ff67416500ca8050d6a341ad04 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 12:31:49 -0800 Subject: [PATCH 035/441] Notification tests. --- .../rx/lang/scala/NotificationTests.scala | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala index 12f8ad3dda..30954ed164 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala @@ -8,7 +8,7 @@ import scala.concurrent.duration._ import scala.language.postfixOps import org.mockito.Mockito._ import org.mockito.Matchers._ -import rx.lang.scala.Notification.{OnError, OnNext} +import rx.lang.scala.Notification.{OnCompleted, OnError, OnNext} class NotificationTests extends JUnitSuite { @@ -17,5 +17,27 @@ class NotificationTests extends JUnitSuite { val onNext = OnNext(42) Assert.assertEquals(42, onNext match { case OnNext(value) => value }) + + val oops = new Exception("Oops") + val onError = OnError(oops) + Assert.assertEquals(oops, onError match { case OnError(error) => error }) + + val onCompleted = OnCompleted() + Assert.assertEquals((), onCompleted match { case OnCompleted() => () }) + } + + @Test + def accept() { + + val onNext = OnNext(42) + Assert.assertEquals(42, onNext.accept(x=>42, e=>4711,()=>13)) + + val oops = new Exception("Oops") + val onError = OnError(oops) + Assert.assertEquals(4711, onError.accept(x=>42, e=>4711,()=>13)) + + val onCompleted = OnCompleted() + Assert.assertEquals(13, onCompleted.accept(x=>42, e=>4711,()=>13)) + } } From 559b6d86964accbd024e8199a41975674c5deffe Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 13:14:19 -0800 Subject: [PATCH 036/441] (Superfluous) Subject tests. --- .../scala/rx/lang/scala/SubjectTests.scala | 239 +++++++++++++++++- 1 file changed, 225 insertions(+), 14 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index be6bb940b2..9d50ac84dc 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -5,7 +5,7 @@ import org.scalatest.junit.JUnitSuite import scala.concurrent.duration._ import scala.language.postfixOps import rx.lang.scala.schedulers.TestScheduler -import rx.lang.scala.subjects.BehaviorSubject +import rx.lang.scala.subjects.{AsyncSubject, ReplaySubject, BehaviorSubject} import org.mockito.Mockito._ import org.mockito.Matchers._ @@ -48,47 +48,258 @@ class SubjectTest extends JUnitSuite { val channel: BehaviorSubject[Integer] = BehaviorSubject(2013) val a = channel.subscribe(observerA) - Assert.assertEquals(2013, lastA) + + Assert.assertEquals(2013, lastA) val b = channel.subscribe(observerB) + + Assert.assertEquals(2013, lastB) + + channel.onNext(42) + + Assert.assertEquals(42, lastA) + Assert.assertEquals(42, lastB) + + a.unsubscribe() + channel.onNext(4711) + + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + channel.onCompleted() + + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + val c = channel.subscribe(observerC) + channel.onNext(13) + + Assert.assertEquals(null, lastC) + Assert.assertTrue(completedC) + + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + channel.onError(new Exception("!")) + + Assert.assertEquals(null, lastC) + Assert.assertTrue(completedC) + + Assert.assertFalse(completedA) + Assert.assertTrue(completedB) + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + + } + + @Test def ReplaySubjectIsAChannel() { + + val channel = ReplaySubject[Int] + + var lastA: Integer = null + var errorA, completedA: Boolean = false + val a = channel.subscribe(x => { lastA = x}, e => { errorA = true} , () => { completedA = true }) + + var lastB: Integer = null + var errorB, completedB: Boolean = false + val b = channel.subscribe(x => { lastB = x}, e => { errorB = true} , () => { completedB = true }) + + channel.onNext(42) + + Assert.assertEquals(42, lastA) + Assert.assertEquals(42, lastB) + + a.unsubscribe() + + channel.onNext(4711) + + Assert.assertEquals(42, lastA) + Assert.assertEquals(4711, lastB) + + channel.onCompleted() + + Assert.assertEquals(42, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + var lastC: Integer = null + var errorC, completedC: Boolean = false + val c = channel.subscribe(x => { lastC = x}, e => { errorC = true} , () => { completedC = true }) + + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onNext(13) + + Assert.assertEquals(42, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onError(new Exception("Boom")) + + Assert.assertEquals(42, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + } + + @Test def BehaviorSubjectIsACache() { + + val channel = BehaviorSubject(2013) + + var lastA: Integer = null + var errorA, completedA: Boolean = false + val a = channel.subscribe(x => { lastA = x}, e => { errorA = true} , () => { completedA = true }) + + var lastB: Integer = null + var errorB, completedB: Boolean = false + val b = channel.subscribe(x => { lastB = x}, e => { errorB = true} , () => { completedB = true }) + + Assert.assertEquals(2013, lastA) Assert.assertEquals(2013, lastB) channel.onNext(42) + Assert.assertEquals(42, lastA) Assert.assertEquals(42, lastB) a.unsubscribe() + channel.onNext(4711) + Assert.assertEquals(42, lastA) Assert.assertEquals(4711, lastB) channel.onCompleted() - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) - val c = channel.subscribe(observerC) - channel.onNext(13) + var lastC: Integer = null + var errorC, completedC: Boolean = false + val c = channel.subscribe(x => { lastC = x}, e => { errorC = true} , () => { completedC = true }) Assert.assertEquals(null, lastC) Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onNext(13) - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) - channel.onError(new Exception("!")) + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) Assert.assertEquals(null, lastC) Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onError(new Exception("Boom")) - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) Assert.assertEquals(42, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + Assert.assertEquals(null, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + } + + @Test def AsyncSubjectIsAFuture() { + + val channel = AsyncSubject[Int]() + + var lastA: Integer = null + var errorA, completedA: Boolean = false + val a = channel.subscribe(x => { lastA = x}, e => { errorA = true} , () => { completedA = true }) + + var lastB: Integer = null + var errorB, completedB: Boolean = false + val b = channel.subscribe(x => { lastB = x}, e => { errorB = true} , () => { completedB = true }) + + channel.onNext(42) + + Assert.assertEquals(null, lastA) + Assert.assertEquals(null, lastB) + + a.unsubscribe() + channel.onNext(4711) + channel.onCompleted() + + Assert.assertEquals(null, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + + var lastC: Integer = null + var errorC, completedC: Boolean = false + val c = channel.subscribe(x => { lastC = x}, e => { errorC = true} , () => { completedC = true }) + + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onNext(13) + + Assert.assertEquals(null, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) + + channel.onError(new Exception("Boom")) + + Assert.assertEquals(null, lastA) + Assert.assertFalse(completedA) + Assert.assertFalse(errorA) + + Assert.assertEquals(4711, lastB) + Assert.assertTrue(completedB) + Assert.assertFalse(errorB) + Assert.assertEquals(4711, lastC) + Assert.assertTrue(completedC) + Assert.assertFalse(errorC) } From d03dd6b6f8e1acdbb7d02df3c26f3f73da90c949 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 14:19:51 -0800 Subject: [PATCH 037/441] Simplified Subject[-T, +R] extends Observable[R] with Observer[T] to Subject[T] extends Observable[T] with Observer[T]. This was a generalization in .NET that did not pan out and Subject is always used with [T,T]. Fought to get multicast to work. I really hate Java variance. --- .../src/main/scala/rx/lang/scala/Observable.scala | 9 ++++----- .../src/main/scala/rx/lang/scala/Subject.scala | 14 ++++++++++---- .../rx/lang/scala/subjects/AsyncSubject.scala | 2 +- .../rx/lang/scala/subjects/BehaviorSubject.scala | 2 +- .../rx/lang/scala/subjects/PublishSubject.scala | 10 ++-------- .../rx/lang/scala/subjects/ReplaySubject.scala | 2 +- .../test/scala/rx/lang/scala/SubjectTests.scala | 12 ++++-------- 7 files changed, 23 insertions(+), 28 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 8231481cad..b41a932b26 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -190,14 +190,13 @@ trait Observable[+T] * * @param subject * the `rx.lang.scala.subjects.Subject` to push source items into - * @tparam R - * result type * @return a pair of a start function and an [[rx.lang.scala.Observable]] such that when the start function * is called, the Observable starts to push results into the specified Subject */ - def multicast[R](subject: rx.lang.scala.Subject[T, R]): (() => Subscription, Observable[R]) = { - val javaCO = asJavaObservable.multicast[R](subject.asJavaSubject) - (() => javaCO.connect(), Observable[R](javaCO)) + def multicast[R >: T](subject: rx.lang.scala.Subject[R]): (() => Subscription, Observable[R]) = { + val s: rx.subjects.Subject[_ >: T, _<: R] = subject.asJavaSubject + val javaCO: rx.observables.ConnectableObservable[R] = asJavaObservable.multicast(s) + (() => javaCO.connect(), Observable(javaCO)) } /** diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala index 13bcb7c756..9bf1500540 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala @@ -20,16 +20,22 @@ import rx.joins.ObserverBase /** * A Subject is an Observable and an Observer at the same time. */ -trait Subject[-T, +R] extends Observable[R] with Observer[T] { - private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] +trait Subject[T] extends Observable[T] with Observer[T] { + private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: T] - val asJavaObservable: rx.Observable[_ <: R] = asJavaSubject + val asJavaObservable: rx.Observable[_ <: T] = asJavaSubject val asJavaObserver: rx.Observer[_ >: T] = asJavaSubject def onNext(value: T): Unit = { asJavaObserver.onNext(value)} def onError(error: Throwable): Unit = { asJavaObserver.onError(error) } def onCompleted() { asJavaObserver.onCompleted() } +} - +object Subject { + def apply[T](): Subject[T] = new rx.lang.scala.subjects.PublishSubject[T](rx.subjects.PublishSubject.create()) } + + + + diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/AsyncSubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/AsyncSubject.scala index 80892b9ac1..44cb6adb79 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/AsyncSubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/AsyncSubject.scala @@ -23,4 +23,4 @@ object AsyncSubject { } } -class AsyncSubject[T] private[scala] (val asJavaSubject: rx.subjects.AsyncSubject[T]) extends Subject[T,T] {} \ No newline at end of file +class AsyncSubject[T] private[scala] (val asJavaSubject: rx.subjects.AsyncSubject[T]) extends Subject[T] {} \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/BehaviorSubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/BehaviorSubject.scala index 9ee8ba9db4..64e0ac4671 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/BehaviorSubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/BehaviorSubject.scala @@ -23,7 +23,7 @@ object BehaviorSubject { } } -class BehaviorSubject[T] private[scala] (val asJavaSubject: rx.subjects.BehaviorSubject[T]) extends Subject[T,T] {} +class BehaviorSubject[T] private[scala] (val asJavaSubject: rx.subjects.BehaviorSubject[T]) extends Subject[T] {} diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala index 7c06101460..74830e8ca6 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala @@ -17,11 +17,5 @@ package rx.lang.scala.subjects import rx.lang.scala.Subject -object PublishSubject { - def apply[T](): PublishSubject[T] = { - new PublishSubject[T](rx.subjects.PublishSubject.create()) - } -} - -class PublishSubject[T] private[scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) extends Subject[T,T] { - } +private [scala] class PublishSubject[T] private[scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) + extends Subject[T] {} diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/ReplaySubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/ReplaySubject.scala index f88fb65280..3f64bf1e7d 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/ReplaySubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/ReplaySubject.scala @@ -23,7 +23,7 @@ object ReplaySubject { } } -class ReplaySubject[T] private[scala] (val asJavaSubject: rx.subjects.ReplaySubject[T]) extends Subject[T,T] { +class ReplaySubject[T] private[scala] (val asJavaSubject: rx.subjects.ReplaySubject[T]) extends Subject[T] { } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 9d50ac84dc..e62a0ef6ee 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -16,7 +16,7 @@ import org.mockito.Matchers._ */ class SubjectTest extends JUnitSuite { - @Test def PublishSubjectIsAChannel() { + @Test def SubjectIsAChannel() { var lastA: Integer = null var errorA: Throwable = null @@ -45,15 +45,13 @@ class SubjectTest extends JUnitSuite { () => { completedC = true } ) - val channel: BehaviorSubject[Integer] = BehaviorSubject(2013) + val channel: Subject[Integer] = Subject[Integer]() val a = channel.subscribe(observerA) - - Assert.assertEquals(2013, lastA) - val b = channel.subscribe(observerB) - Assert.assertEquals(2013, lastB) + Assert.assertEquals(null, lastA) + Assert.assertEquals(null, lastB) channel.onNext(42) @@ -93,8 +91,6 @@ class SubjectTest extends JUnitSuite { Assert.assertTrue(completedB) Assert.assertEquals(42, lastA) Assert.assertEquals(4711, lastB) - - } @Test def ReplaySubjectIsAChannel() { From de38dbba54edc1f7146c1d7f8d66e9885c8ab5d1 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 14:26:25 -0800 Subject: [PATCH 038/441] Updated release notes for Subject[T] --- language-adaptors/rxjava-scala/ReleaseNotes.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 4a3d222b72..2e3cb9881c 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -24,11 +24,11 @@ trait Observer[-T] { object Observer {...} ``` -To create an instance of say `Observer[String]` in user code, you can create a new instance of the `Observer` trait +To create an instance of say `Observer[SensorEvent]` in user code, you can create a new instance of the `Observer` trait and implement any of the methods that you care about: ```scala - val printObserver = new Observer[String] { - override def onNext(value: String): Unit = {...} + val printObserver = new Observer[SensorEvent] { + override def onNext(value: SensorEvent): Unit = {...value.toString...} override def onError(error: Throwable): Unit = {...} override def onCompleted(): Unit = {...} } @@ -65,15 +65,15 @@ The major changes in `Observable` are wrt to the factory methods *Can't write th Subject ------- -The `Subject` trait now also hides the underlying Java `asJavaSubject: rx.subjects.Subject[_ >: T, _<: R]`. +The `Subject` trait now also hides the underlying Java `asJavaSubject: rx.subjects.Subject[_ >: T, _<: T]` +and takes only a single *invariant* type parameter `T`. all existing implementations of `Subject` are parametrized +by a single type, and this reflects that reality. ```scala -trait Subject[-T, +R] extends Observable[R] with Observer[T] { - private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: R] +trait Subject[T] extends Observable[T] with Observer[T] { + private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: T] } ``` - -*I will remove PublishSubject making it *Subject* There is no companion object for `Subject` but instead* For each kind of subject, there is a pair of a companion object and a class with a private constructor: ```scala @@ -97,7 +97,7 @@ The latter is still missing various overloads http://msdn.microsoft.com/en-us/li you can expect to appear once they are added to the underlying RxJava implementation. Compared with release 0.15.1 there are no breaking changes in `Subject` for this release, except for -making `asJavaSubject` private. +making `asJavaSubject` private, and collapsing its type parameters. Neither of these should cause trouble. Schedulers ---------- From d2c2fbf8d085606a68d67c3a7234f18e0be016f6 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 19:01:52 -0800 Subject: [PATCH 039/441] README * Needed to comment out interop test because, build cannot find my javac. * Note scheduler test don't terminate with JDK 7 on my machine. --- language-adaptors/rxjava-scala/ReleaseNotes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 2e3cb9881c..9584a07090 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -60,7 +60,7 @@ object Observable { } ``` -The major changes in `Observable` are wrt to the factory methods *Can't write this when I don't have Samuel's changes*. +The major changes in `Observable` are wrt to the factory methods *TODO: add constructor changes*. Subject ------- From 41fb1f3dfb68d613a25a72ededfa708db17b94bd Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 19:20:15 -0800 Subject: [PATCH 040/441] Interop Helpers --- .../rxjava-scala/ReleaseNotes.md | 25 ++++++++++++++++++- .../scala/rx/lang/scala/JavaConversions.scala | 1 - .../main/scala/rx/lang/scala/Observer.scala | 3 --- 3 files changed, 24 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 9584a07090..998bf460d2 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -149,7 +149,6 @@ and `BooleanSubscription`, and the latter has been removed from the public surfa trait Subscription { private [scala] val asJavaSubscription: rx.Subscription = {...} - private [scala] val unsubscribed = new AtomicBoolean(false) def unsubscribe(): Unit = { ... } def isUnsubscribed: Boolean = ... @@ -192,3 +191,27 @@ or `OnError(new Exception("Oops!"))`, or `OnCompleted()`. To pattern match on a notification you can create a partial function like so: `case OnNext(v) => { ... v ... }`. There are no breaking changes for notifications. + +Java Interop Helpers +-------------------- + +Since the Scala traits *wrap* the underlying Java types, yoo may occasionally will have to wrap an unwrap +between the two representations. The `JavaConversion` object provides helper functions of the form `toJavaXXX` and +`toScalaXXX` for this purpose. Note these are defined as implicit conversions in Scala. + +```scala +object JavaConversions { + import language.implicitConversions + + implicit def toJavaNotification[T](s: Notification[T]): rx.Notification[_ <: T] = {...} + implicit def toScalaNotification[T](s: rx.Notification[_ <: T]): Notification[T] = {...} + implicit def toJavaSubscription(s: Subscription): rx.Subscription = {...} + implicit def toScalaSubscription(s: rx.Subscription): Subscription = {...} + implicit def scalaSchedulerToJavaScheduler(s: Scheduler): rx.Scheduler = {...} + implicit def javaSchedulerToScalaScheduler(s: rx.Scheduler): Scheduler = {...} + implicit def toJavaObserver[T](s: Observer[T]): rx.Observer[_ >: T] = {...} + implicit def toScalaObserver[T](s: rx.Observer[_ >: T]): Observer[T] = {...} + implicit def toJavaObservable[T](s: Observable[T]): rx.Observable[_ <: T] = {...} + implicit def toScalaObservable[T](observable: rx.Observable[_ <: T]): Observable[T] = {...} +} +``` \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala index b8067c63cd..48fe22685b 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala @@ -32,5 +32,4 @@ object JavaConversions { val asJavaObservable = observable } } - } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index eb42e8ce81..1976285ec6 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -15,9 +15,6 @@ */ package rx.lang.scala -import rx.joins.ObserverBase -import java.util.concurrent.atomic.AtomicBoolean - /** Provides a mechanism for receiving push-based notifications. * From 80527c95bdf49512de8804b50fa4debec75f2a1e Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sat, 7 Dec 2013 19:44:51 -0800 Subject: [PATCH 041/441] Documented factory method changes. and also Notification.asJava => Notfication.asJavaNotification Conflicts: language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala --- .../rxjava-scala/ReleaseNotes.md | 19 +++++++--- .../scala/rx/lang/scala/JavaConversions.scala | 2 +- .../scala/rx/lang/scala/Notification.scala | 36 +++++++++---------- .../main/scala/rx/lang/scala/Observable.scala | 4 +-- 4 files changed, 36 insertions(+), 25 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 998bf460d2..92c3dac9e0 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -40,8 +40,9 @@ Note that typically you do not need to create an `Observer` since all of the met (for instance `subscribe`) usually come with overloads that accept the individual methods `onNext`, `onError`, and `onCompleted` and will automatically create an `Observer` for you under the covers. -While *technically* it is a breaking change make the `asJavaObserver` property -private, you should probably not have touched `asJavaObserver` in the first place. +While *technically* it is a breaking change make the `asJavaObserver` property private, you should probably not have +touched `asJavaObserver` in the first place. If you really feel you need to access the underlying `rx.Observer` +call `toJava`. Observable ---------- @@ -60,7 +61,15 @@ object Observable { } ``` -The major changes in `Observable` are wrt to the factory methods *TODO: add constructor changes*. +The major changes in `Observable` are wrt to the factory methods where too libral use of overloading of the `apply` +method hindered type inference and made Scala code look unnecessarily different than that in other language bindings. +In fact the only occurence left of `apply` if for the varargs case. All other factory methods now have their own name. + +* `def apply[T](items: T*): Observable[T]` +* `def from[T](f: Future[T]): Observable[T]` +* `def from[T](iterable: Iterable[T]): Observable[T]` +* `def create[T](subscribe: Observer[T] => Subscription): Observable[T]` +* `def error[T](exception: Throwable): Observable[T]` Subject ------- @@ -197,7 +206,9 @@ Java Interop Helpers Since the Scala traits *wrap* the underlying Java types, yoo may occasionally will have to wrap an unwrap between the two representations. The `JavaConversion` object provides helper functions of the form `toJavaXXX` and -`toScalaXXX` for this purpose. Note these are defined as implicit conversions in Scala. +`toScalaXXX` for this purpose, properly hiding how precisely the wrapped types are stored. +Note the (un)wrap conversions are defined as implicits in Scala, but in the unlikely event that you do need them +be kind to the reader of your code and call them explicitly. ```scala object JavaConversions { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala index 48fe22685b..cc380c463c 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala @@ -9,7 +9,7 @@ package rx.lang.scala object JavaConversions { import language.implicitConversions - implicit def toJavaNotification[T](s: Notification[T]): rx.Notification[_ <: T] = s.asJava + implicit def toJavaNotification[T](s: Notification[T]): rx.Notification[_ <: T] = s.asJavaNotification implicit def toScalaNotification[T](s: rx.Notification[_ <: T]): Notification[T] = Notification(s) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index 472c09f2ee..edc9eaf6d8 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -19,7 +19,13 @@ package rx.lang.scala * Emitted by Observables returned by [[rx.lang.scala.Observable.materialize]]. */ sealed trait Notification[+T] { - private [scala] val asJava: rx.Notification[_ <: T] + private [scala] val asJavaNotification: rx.Notification[_ <: T] + + override def equals(that: Any): Boolean = that match { + case other: Notification[_] => asJavaNotification.equals(other.asJavaNotification) + case _ => false + } + override def hashCode(): Int = asJavaNotification.hashCode() /** * Invokes the function corresponding to the notification. @@ -38,12 +44,6 @@ sealed trait Notification[+T] { case Notification.OnCompleted() => onCompleted() } } - - override def equals(that: Any): Boolean = that match { - case other: Notification[_] => asJava.equals(other.asJava) - case _ => false - } - override def hashCode(): Int = asJava.hashCode() } /** @@ -69,12 +69,7 @@ object Notification { // OnNext, OnError, OnCompleted are not case classes because we don't want pattern matching // to extract the rx.Notification - - class OnNext[+T] private[scala] (val asJava: rx.Notification[_ <: T]) extends Notification[T] { - def value: T = asJava.getValue - override def toString = s"OnNext($value)" - } - + object OnNext { /** @@ -100,9 +95,9 @@ object Notification { } } - class OnError[+T] private[scala] (val asJava: rx.Notification[_ <: T]) extends Notification[T] { - def error: Throwable = asJava.getThrowable - override def toString = s"OnError($error)" + class OnNext[+T] private[scala] (val asJavaNotification: rx.Notification[_ <: T]) extends Notification[T] { + def value: T = asJavaNotification.getValue + override def toString = s"OnNext($value)" } object OnError { @@ -131,8 +126,9 @@ object Notification { } } - class OnCompleted[T] private[scala] (val asJava: rx.Notification[_ <: T]) extends Notification[T] { - override def toString = "OnCompleted()" + class OnError[+T] private[scala] (val asJavaNotification: rx.Notification[_ <: T]) extends Notification[T] { + def error: Throwable = asJavaNotification.getThrowable + override def toString = s"OnError($error)" } object OnCompleted { @@ -153,5 +149,9 @@ object Notification { } } + class OnCompleted[T] private[scala](val asJavaNotification: rx.Notification[_ <: T]) extends Notification[T] { + override def toString = "OnCompleted()" + } + } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index ba84f98f5f..0b92f6f253 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -837,7 +837,7 @@ trait Observable[+T] // with =:= it does not work, why? def dematerialize[U](implicit evidence: Observable[T] <:< Observable[Notification[U]]): Observable[U] = { val o1: Observable[Notification[U]] = this - val o2: Observable[rx.Notification[_ <: U]] = o1.map(_.asJava) + val o2: Observable[rx.Notification[_ <: U]] = o1.map(_.asJavaNotification) val o3 = o2.asJavaObservable.dematerialize[U]() toScalaObservable[U](o3) } @@ -1137,7 +1137,7 @@ trait Observable[+T] */ def forall(predicate: T => Boolean): Observable[Boolean] = { // type mismatch; found : rx.Observable[java.lang.Boolean] required: rx.Observable[_ <: scala.Boolean] - // new Observable[Boolean](asJava.all(predicate)) + // new Observable[Boolean](asJavaNotification.all(predicate)) // it's more fun in Scala: this.map(predicate).foldLeft(true)(_ && _) } From 265a6d24aaf2b86618b8d45198f51fa55aba437b Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sun, 8 Dec 2013 13:06:44 +0100 Subject: [PATCH 042/441] remove rx.lang.scala.subscriptions.SubscriptionTests, because rx.lang.scala.SubscriptionTests is more up to date --- .../subscriptions/SubscriptionTests.scala | 118 ------------------ 1 file changed, 118 deletions(-) delete mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala deleted file mode 100644 index 4309967c0a..0000000000 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subscriptions/SubscriptionTests.scala +++ /dev/null @@ -1,118 +0,0 @@ -package rx.lang.scala.subscriptions - -import org.junit.Assert._ -import org.junit.Test -import org.scalatest.junit.JUnitSuite - -import rx.lang.scala.Subscription - -class SubscriptionTests extends JUnitSuite { - - @Test - def anonymousSubscriptionCreate() { - val subscription = Subscription{} - assertNotNull(subscription) - } - - @Test - def anonymousSubscriptionDispose() { - var unsubscribed = false - val subscription = Subscription{ unsubscribed = true } - assertFalse(unsubscribed) - subscription.unsubscribe() - assertTrue(unsubscribed) - } - - @Test - def emptySubscription() { - val subscription = Subscription() - subscription.unsubscribe() - } - - @Test - def booleanSubscription() { - val subscription = BooleanSubscription() - assertFalse(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - subscription.unsubscribe() - assertTrue(subscription.isUnsubscribed) - } - - @Test - def compositeSubscriptionAdd() { - - var u0 = false - val s0 = BooleanSubscription{ u0 = true } - - var u1 = false - val s1 = Subscription{ u1 = true } - - val composite = CompositeSubscription() - - assertFalse(composite.isUnsubscribed) - - composite += s0 - composite += s1 - - composite.unsubscribe() - - assertTrue(composite.isUnsubscribed) - assertTrue(s0.isUnsubscribed) - assertTrue(u0) - assertTrue(u1) - - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - composite += s2 - assertTrue(s2.isUnsubscribed) - - } - - @Test - def compositeSubscriptionRemove() { - - val s0 = BooleanSubscription() - val composite = CompositeSubscription() - - composite += s0 - assertFalse(s0.isUnsubscribed) - composite -= s0 - assertTrue(s0.isUnsubscribed) - - composite.unsubscribe() - - assertTrue(composite.isUnsubscribed) - } - - @Test - def multiAssignmentSubscriptionAdd() { - - val s0 = BooleanSubscription() - val s1 = BooleanSubscription() - val multiple = MultipleAssignmentSubscription() - - assertFalse(multiple.isUnsubscribed) - - multiple.subscription = s0 - assertEquals(s0.asJavaSubscription, multiple.subscription.asJavaSubscription) - - multiple.subscription = s1 - assertEquals(s1.asJavaSubscription, multiple.subscription.asJavaSubscription) - - assertFalse(s0.isUnsubscribed) - assertFalse(s1.isUnsubscribed) - - multiple.unsubscribe() - - assertTrue(multiple.isUnsubscribed) - assertFalse(s0.isUnsubscribed) - assertTrue(s1.isUnsubscribed) - - val s2 = BooleanSubscription() - assertFalse(s2.isUnsubscribed) - multiple.subscription = s2 - assertTrue(s2.isUnsubscribed) - } - -} From c194d73617d05aa3a5af31a7e8c363da30d1f72e Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sun, 8 Dec 2013 13:41:02 +0100 Subject: [PATCH 043/441] fix one constructor usage --- .../src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala index f696a47e12..ae041512d2 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala @@ -137,7 +137,7 @@ class RxScalaDemo extends JUnitSuite { } @Test def windowExample() { - (for ((o, i) <- Observable(1 to 18).window(5).zipWithIndex; n <- o) + (for ((o, i) <- Observable.from(1 to 18).window(5).zipWithIndex; n <- o) yield s"Observable#$i emits $n" ).subscribe(output(_)) } From f7c5dd05864a1f0bc7228436b0891f8c684345aa Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sun, 8 Dec 2013 13:41:36 +0100 Subject: [PATCH 044/441] reorg imports of TestSchedulerExample --- .../scala/examples/TestSchedulerExample.scala | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala index 800cd9aaf0..2e53f1afe9 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala @@ -1,21 +1,19 @@ package rx.lang.scala.examples -import org.junit.{Assert, Test} -import org.scalatest.junit.JUnitSuite -import scala.concurrent.duration._ +import scala.concurrent.duration.DurationInt import scala.language.postfixOps -import rx.lang.scala.{ Observable, Observer } -import rx.lang.scala.schedulers.TestScheduler -import rx.lang.scala.subjects.BehaviorSubject -import org.mockito.Mockito._ + +import org.junit.Test import org.mockito.Matchers._ +import org.mockito.Mockito._ +import org.scalatest.junit.JUnitSuite + +import rx.lang.scala._ +import rx.lang.scala.schedulers.TestScheduler class TestSchedulerExample extends JUnitSuite { @Test def testInterval() { - import org.mockito.Matchers._ - import org.mockito.Mockito._ - val scheduler = TestScheduler() // Use a Java Observer for Mockito val observer = mock(classOf[rx.Observer[Long]]) From d9f31d1b2a0ec31e434ba9759b90f733f9b87c62 Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sun, 8 Dec 2013 13:45:01 +0100 Subject: [PATCH 045/441] undo undesired side effects of search/replace which were introduced by commit https://github.com/Applied-Duality/RxJava/commit/a0aa6db735481652fd9fab4c21ab7f83928efb22 --- rxjava-core/src/test/java/rx/SchedulersTest.java | 2 +- .../java/rx/operators/SynchronizedObserverTest.java | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/rxjava-core/src/test/java/rx/SchedulersTest.java b/rxjava-core/src/test/java/rx/SchedulersTest.java index 211556cd58..c9d97054d0 100644 --- a/rxjava-core/src/test/java/rx/SchedulersTest.java +++ b/rxjava-core/src/test/java/rx/SchedulersTest.java @@ -460,7 +460,7 @@ public void run() { } if (observer.error.get() == null) { - fail("We expected error messages due to schedulers"); + fail("We expected error messages due to concurrency"); } } diff --git a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java index cde19532a3..f1c40c3674 100644 --- a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java +++ b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java @@ -88,7 +88,7 @@ public void testMultiThreadedBasic() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -128,7 +128,7 @@ public void testMultiThreadedBasicWithLock() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -160,7 +160,7 @@ public void testMultiThreadedWithNPE() { // so commenting out for now as this is not a critical thing to test here //verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -206,7 +206,7 @@ public void testMultiThreadedWithNPEAndLock() { // so commenting out for now as this is not a critical thing to test here //verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -236,7 +236,7 @@ public void testMultiThreadedWithNPEinMiddle() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); @@ -280,7 +280,7 @@ public void testMultiThreadedWithNPEinMiddleAndLock() { // so commenting out for now as this is not a critical thing to test here // verify(s, times(1)).unsubscribe(); - // we can have schedulers ... + // we can have concurrency ... assertTrue(onSubscribe.maxConcurrentThreads.get() > 1); // ... but the onNext execution should be single threaded assertEquals(1, busyObserver.maxConcurrentThreads.get()); From 44bb01c0cb8e63e1aad35c616885e2ae5ec440a3 Mon Sep 17 00:00:00 2001 From: samuelgruetter Date: Sun, 8 Dec 2013 14:01:06 +0100 Subject: [PATCH 046/441] fix constructor usage in ObservableTest --- .../src/test/scala/rx/lang/scala/ObservableTest.scala | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index d24c57710f..6540a6afcd 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -61,7 +61,7 @@ class ObservableTests extends JUnitSuite { @Test def testFirstOrElse() { def mustNotBeCalled: String = sys.error("this method should not be called") def mustBeCalled: String = "this is the default value" - assertEquals("hello", Observable.from("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) + assertEquals("hello", Observable("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) assertEquals("this is the default value", Observable().firstOrElse(mustBeCalled).toBlockingObservable.single) } @@ -112,10 +112,4 @@ class ObservableTests extends JUnitSuite { } */ - //@Test def testTest() = { - //val a: Observable[Int] = Observable.from() - //assertEquals(4, Observable.from(1, 2, 3, 4).toBlockingObservable.toIterable.last) - //println("This UnitTestSuite.testTest() for rx.lang.scala.Observable") - //} - } From c335addd037c26801bd3b2b257122a8959e4a4b7 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 11:22:40 -0800 Subject: [PATCH 047/441] Updated release notes --- .../rxjava-scala/ReleaseNotes.md | 39 +++++++++---------- 1 file changed, 18 insertions(+), 21 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 92c3dac9e0..7da54a9374 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -14,8 +14,6 @@ In this release we have made the `asJavaObserver` property in `Observable[T]`as ```scala trait Observer[-T] { - private [scala] def asJavaObserver: rx.Observer[_ >: T] - def onNext(value: T): Unit def onError(error: Throwable): Unit def onCompleted(): Unit @@ -53,11 +51,13 @@ Again, while *technically* this is a breaking change, this should not have any i ```scala trait Observable[+T] { - private [scala] val asJavaObservable: rx.Observable[_ <: T] + def subscribe(observer: Observer[T]): Subscription = {...} + def apply(observer: Observer[T]): Subscription = {...} + ... } - object Observable { - private [scala] def apply[T](observable: rx.Observable[_ <: T]): Observable[T] = {...} + def create[T](func: Observer[T] => Subscription): Observable[T] = {...} + ... } ``` @@ -79,17 +79,17 @@ and takes only a single *invariant* type parameter `T`. all existing implementat by a single type, and this reflects that reality. ```scala -trait Subject[T] extends Observable[T] with Observer[T] { - private [scala] val asJavaSubject: rx.subjects.Subject[_ >: T, _<: T] +trait Subject[T] extends Observable[T] with Observer[T] {} +object Subject { + def apply(): Subject[T] = {...} } ``` -For each kind of subject, there is a pair of a companion object and a class with a private constructor: +For each kind of subject, there is a class with a private constructor and a companion object +that you should use to create a new kind of subject : ```scala object XXXSubject { - def apply[T](...): XXXSubject[T] = { - new XXXSubject[T](... create corresponding rx subject ...) - } + def apply[T](...): XXXSubject[T] = {...} } class XXXSubject[T] private[scala] (val asJavaSubject: rx.subjects.XXXSubject[T]) extends Subject[T,T] {} @@ -116,11 +116,7 @@ The trait itself remains unchanged, except that we made the underlying Java repr The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.lang.scala.schedulers`. ```scala -trait Scheduler { - private[scala] val asJavaScheduler: rx.Scheduler; -} - -private [scala] object Scheduler {...} +trait Scheduler {...} ``` In the previous release, you created schedulers by selecting them from the `Schedulers` object, @@ -156,9 +152,6 @@ and `BooleanSubscription`, and the latter has been removed from the public surfa ```scala trait Subscription { - - private [scala] val asJavaSubscription: rx.Subscription = {...} - def unsubscribe(): Unit = { ... } def isUnsubscribed: Boolean = ... } @@ -185,9 +178,13 @@ objects of `Notification` now have both constructor (`apply`) and extractor (`un ```scala object Notification {...} trait Notification[+T] { - private [scala] val asJavaNotification: rx.Notification[_ <: T] + override def equals(that: Any): Boolean = {...} + override def hashCode(): Int = {...} + def accept[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = {...} } - +``` +The nested companion objects of `Notification` now have both constructor (`apply`) and extractor (`unapply`) functions: +```scala object Notification { object OnNext { def apply(...){}; def unapply(...){...} } object OnError { def apply(...){}; def unapply(...){...} } From f39bca6b8bc0eec268974392b66dc0739fe19335 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 11:30:11 -0800 Subject: [PATCH 048/441] renamed `accept` to `apply` for Notification. --- .../src/main/scala/rx/lang/scala/Notification.scala | 2 +- .../src/test/scala/rx/lang/scala/NotificationTests.scala | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index edc9eaf6d8..de5839a4d0 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -37,7 +37,7 @@ sealed trait Notification[+T] { * @param onCompleted * The function to invoke for an [[rx.lang.scala.Notification.OnCompleted]] notification. */ - def accept[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = { + def apply[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = { this match { case Notification.OnNext(value) => onNext(value) case Notification.OnError(error) => onError(error) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala index 30954ed164..c1bd7020e3 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala @@ -30,14 +30,14 @@ class NotificationTests extends JUnitSuite { def accept() { val onNext = OnNext(42) - Assert.assertEquals(42, onNext.accept(x=>42, e=>4711,()=>13)) + Assert.assertEquals(42, onNext(x=>42, e=>4711,()=>13)) val oops = new Exception("Oops") val onError = OnError(oops) - Assert.assertEquals(4711, onError.accept(x=>42, e=>4711,()=>13)) + Assert.assertEquals(4711, onError(x=>42, e=>4711,()=>13)) val onCompleted = OnCompleted() - Assert.assertEquals(13, onCompleted.accept(x=>42, e=>4711,()=>13)) + Assert.assertEquals(13, onCompleted(x=>42, e=>4711,()=>13)) } } From 4ef1a3717d0c223f63da6a83c98777ad5ac42f2d Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 11:59:17 -0800 Subject: [PATCH 049/441] CRemoved Assert. prefix from tests --- .../rx/lang/scala/NotificationTests.scala | 14 +- .../scala/rx/lang/scala/SubjectTests.scala | 170 +++++++++--------- .../rx/lang/scala/SubscriptionTests.scala | 85 ++++----- 3 files changed, 137 insertions(+), 132 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala index c1bd7020e3..759ca8b7ec 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala @@ -2,7 +2,7 @@ package rx.lang.scala import org.junit.{Assert, Test} -import org.junit.Assert +import org.junit.Assert._ import org.scalatest.junit.JUnitSuite import scala.concurrent.duration._ import scala.language.postfixOps @@ -16,28 +16,28 @@ class NotificationTests extends JUnitSuite { def creation() { val onNext = OnNext(42) - Assert.assertEquals(42, onNext match { case OnNext(value) => value }) + assertEquals(42, onNext match { case OnNext(value) => value }) val oops = new Exception("Oops") val onError = OnError(oops) - Assert.assertEquals(oops, onError match { case OnError(error) => error }) + assertEquals(oops, onError match { case OnError(error) => error }) val onCompleted = OnCompleted() - Assert.assertEquals((), onCompleted match { case OnCompleted() => () }) + assertEquals((), onCompleted match { case OnCompleted() => () }) } @Test def accept() { val onNext = OnNext(42) - Assert.assertEquals(42, onNext(x=>42, e=>4711,()=>13)) + assertEquals(42, onNext(x=>42, e=>4711,()=>13)) val oops = new Exception("Oops") val onError = OnError(oops) - Assert.assertEquals(4711, onError(x=>42, e=>4711,()=>13)) + assertEquals(4711, onError(x=>42, e=>4711,()=>13)) val onCompleted = OnCompleted() - Assert.assertEquals(13, onCompleted(x=>42, e=>4711,()=>13)) + assertEquals(13, onCompleted(x=>42, e=>4711,()=>13)) } } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index e62a0ef6ee..6a6cadda53 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -8,12 +8,14 @@ import rx.lang.scala.schedulers.TestScheduler import rx.lang.scala.subjects.{AsyncSubject, ReplaySubject, BehaviorSubject} import org.mockito.Mockito._ import org.mockito.Matchers._ +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Assert.assertFalse +import org.junit.Ignore +import org.junit.Test +import org.scalatest.junit.JUnitSuite -/** - * No fucking clue how to properly mock traits. - * Some old-school imperative code works just as well. - */ class SubjectTest extends JUnitSuite { @Test def SubjectIsAChannel() { @@ -50,47 +52,47 @@ class SubjectTest extends JUnitSuite { val a = channel.subscribe(observerA) val b = channel.subscribe(observerB) - Assert.assertEquals(null, lastA) - Assert.assertEquals(null, lastB) + assertEquals(null, lastA) + assertEquals(null, lastB) channel.onNext(42) - Assert.assertEquals(42, lastA) - Assert.assertEquals(42, lastB) + assertEquals(42, lastA) + assertEquals(42, lastB) a.unsubscribe() channel.onNext(4711) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertEquals(42, lastA) + assertEquals(4711, lastB) channel.onCompleted() - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertFalse(completedA) + assertTrue(completedB) + assertEquals(42, lastA) + assertEquals(4711, lastB) val c = channel.subscribe(observerC) channel.onNext(13) - Assert.assertEquals(null, lastC) - Assert.assertTrue(completedC) + assertEquals(null, lastC) + assertTrue(completedC) - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertFalse(completedA) + assertTrue(completedB) + assertEquals(42, lastA) + assertEquals(4711, lastB) channel.onError(new Exception("!")) - Assert.assertEquals(null, lastC) - Assert.assertTrue(completedC) + assertEquals(null, lastC) + assertTrue(completedC) - Assert.assertFalse(completedA) - Assert.assertTrue(completedB) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertFalse(completedA) + assertTrue(completedB) + assertEquals(42, lastA) + assertEquals(4711, lastB) } @Test def ReplaySubjectIsAChannel() { @@ -107,61 +109,61 @@ class SubjectTest extends JUnitSuite { channel.onNext(42) - Assert.assertEquals(42, lastA) - Assert.assertEquals(42, lastB) + assertEquals(42, lastA) + assertEquals(42, lastB) a.unsubscribe() channel.onNext(4711) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertEquals(42, lastA) + assertEquals(4711, lastB) channel.onCompleted() - Assert.assertEquals(42, lastA) - Assert.assertFalse(completedA) - Assert.assertFalse(errorA) + assertEquals(42, lastA) + assertFalse(completedA) + assertFalse(errorA) - Assert.assertEquals(4711, lastB) - Assert.assertTrue(completedB) - Assert.assertFalse(errorB) + assertEquals(4711, lastB) + assertTrue(completedB) + assertFalse(errorB) var lastC: Integer = null var errorC, completedC: Boolean = false val c = channel.subscribe(x => { lastC = x}, e => { errorC = true} , () => { completedC = true }) - Assert.assertEquals(4711, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(4711, lastC) + assertTrue(completedC) + assertFalse(errorC) channel.onNext(13) - Assert.assertEquals(42, lastA) - Assert.assertFalse(completedA) - Assert.assertFalse(errorA) + assertEquals(42, lastA) + assertFalse(completedA) + assertFalse(errorA) - Assert.assertEquals(4711, lastB) - Assert.assertTrue(completedB) - Assert.assertFalse(errorB) + assertEquals(4711, lastB) + assertTrue(completedB) + assertFalse(errorB) - Assert.assertEquals(4711, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(4711, lastC) + assertTrue(completedC) + assertFalse(errorC) channel.onError(new Exception("Boom")) - Assert.assertEquals(42, lastA) - Assert.assertFalse(completedA) - Assert.assertFalse(errorA) + assertEquals(42, lastA) + assertFalse(completedA) + assertFalse(errorA) - Assert.assertEquals(4711, lastB) - Assert.assertTrue(completedB) - Assert.assertFalse(errorB) + assertEquals(4711, lastB) + assertTrue(completedB) + assertFalse(errorB) - Assert.assertEquals(4711, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(4711, lastC) + assertTrue(completedC) + assertFalse(errorC) } @Test def BehaviorSubjectIsACache() { @@ -176,20 +178,20 @@ class SubjectTest extends JUnitSuite { var errorB, completedB: Boolean = false val b = channel.subscribe(x => { lastB = x}, e => { errorB = true} , () => { completedB = true }) - Assert.assertEquals(2013, lastA) - Assert.assertEquals(2013, lastB) + assertEquals(2013, lastA) + assertEquals(2013, lastB) channel.onNext(42) - Assert.assertEquals(42, lastA) - Assert.assertEquals(42, lastB) + assertEquals(42, lastA) + assertEquals(42, lastB) a.unsubscribe() channel.onNext(4711) - Assert.assertEquals(42, lastA) - Assert.assertEquals(4711, lastB) + assertEquals(42, lastA) + assertEquals(4711, lastB) channel.onCompleted() @@ -197,37 +199,37 @@ class SubjectTest extends JUnitSuite { var errorC, completedC: Boolean = false val c = channel.subscribe(x => { lastC = x}, e => { errorC = true} , () => { completedC = true }) - Assert.assertEquals(null, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(null, lastC) + assertTrue(completedC) + assertFalse(errorC) channel.onNext(13) - Assert.assertEquals(42, lastA) - Assert.assertFalse(completedA) - Assert.assertFalse(errorA) + assertEquals(42, lastA) + assertFalse(completedA) + assertFalse(errorA) - Assert.assertEquals(4711, lastB) - Assert.assertTrue(completedB) - Assert.assertFalse(errorB) + assertEquals(4711, lastB) + assertTrue(completedB) + assertFalse(errorB) - Assert.assertEquals(null, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(null, lastC) + assertTrue(completedC) + assertFalse(errorC) channel.onError(new Exception("Boom")) - Assert.assertEquals(42, lastA) - Assert.assertFalse(completedA) - Assert.assertFalse(errorA) + assertEquals(42, lastA) + assertFalse(completedA) + assertFalse(errorA) - Assert.assertEquals(4711, lastB) - Assert.assertTrue(completedB) - Assert.assertFalse(errorB) + assertEquals(4711, lastB) + assertTrue(completedB) + assertFalse(errorB) - Assert.assertEquals(null, lastC) - Assert.assertTrue(completedC) - Assert.assertFalse(errorC) + assertEquals(null, lastC) + assertTrue(completedC) + assertFalse(errorC) } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index cf8aa415a6..a9e9cf6b27 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -8,6 +8,9 @@ import scala.concurrent.duration._ import scala.language.postfixOps import org.mockito.Mockito._ import org.mockito.Matchers._ +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Assert.assertFalse import rx.lang.scala.subscriptions.{SerialSubscription, MultipleAssignmentSubscription, CompositeSubscription} @@ -18,10 +21,10 @@ class SubscriptionTests extends JUnitSuite { val subscription = Subscription() - Assert.assertFalse(subscription.isUnsubscribed) + assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() - Assert.assertTrue(subscription.isUnsubscribed) + assertTrue(subscription.isUnsubscribed) } @Test @@ -30,16 +33,16 @@ class SubscriptionTests extends JUnitSuite { val subscription = Subscription{ called = !called } - Assert.assertFalse(called) - Assert.assertFalse(subscription.isUnsubscribed) + assertFalse(called) + assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() - Assert.assertTrue(called) - Assert.assertTrue(subscription.isUnsubscribed) + assertTrue(called) + assertTrue(subscription.isUnsubscribed) subscription.unsubscribe() - Assert.assertTrue(called) - Assert.assertTrue(subscription.isUnsubscribed) + assertTrue(called) + assertTrue(subscription.isUnsubscribed) } @Test @@ -50,21 +53,21 @@ class SubscriptionTests extends JUnitSuite { val composite = CompositeSubscription() - Assert.assertFalse(composite.isUnsubscribed) + assertFalse(composite.isUnsubscribed) composite += s0 composite += s1 composite.unsubscribe() - Assert.assertTrue(composite.isUnsubscribed) - Assert.assertTrue(s0.isUnsubscribed) - Assert.assertTrue(s0.isUnsubscribed) + assertTrue(composite.isUnsubscribed) + assertTrue(s0.isUnsubscribed) + assertTrue(s0.isUnsubscribed) val s2 = Subscription{} - Assert.assertFalse(s2.isUnsubscribed) + assertFalse(s2.isUnsubscribed) composite += s2 - Assert.assertTrue(s2.isUnsubscribed) + assertTrue(s2.isUnsubscribed) } @@ -75,13 +78,13 @@ class SubscriptionTests extends JUnitSuite { val composite = CompositeSubscription() composite += s0 - Assert.assertFalse(s0.isUnsubscribed) + assertFalse(s0.isUnsubscribed) composite -= s0 - Assert.assertTrue(s0.isUnsubscribed) + assertTrue(s0.isUnsubscribed) composite.unsubscribe() - Assert.assertTrue(composite.isUnsubscribed) + assertTrue(composite.isUnsubscribed) } @Test @@ -91,28 +94,28 @@ class SubscriptionTests extends JUnitSuite { val s1 = Subscription() val multiple = MultipleAssignmentSubscription() - Assert.assertFalse(multiple.isUnsubscribed) - Assert.assertFalse(s0.isUnsubscribed) - Assert.assertFalse(s1.isUnsubscribed) + assertFalse(multiple.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) multiple.subscription = s0 - Assert.assertFalse(s0.isUnsubscribed) - Assert.assertFalse(s1.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) multiple.subscription = s1 - Assert.assertFalse(s0.isUnsubscribed) // difference with SerialSubscription - Assert.assertFalse(s1.isUnsubscribed) + assertFalse(s0.isUnsubscribed) // difference with SerialSubscription + assertFalse(s1.isUnsubscribed) multiple.unsubscribe() - Assert.assertTrue(multiple.isUnsubscribed) - Assert.assertFalse(s0.isUnsubscribed) - Assert.assertTrue(s1.isUnsubscribed) + assertTrue(multiple.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertTrue(s1.isUnsubscribed) val s2 = Subscription() - Assert.assertFalse(s2.isUnsubscribed) + assertFalse(s2.isUnsubscribed) multiple.subscription = s2 - Assert.assertTrue(s2.isUnsubscribed) - Assert.assertFalse(s0.isUnsubscribed) + assertTrue(s2.isUnsubscribed) + assertFalse(s0.isUnsubscribed) } @Test @@ -122,25 +125,25 @@ class SubscriptionTests extends JUnitSuite { val s1 = Subscription() val serial = SerialSubscription() - Assert.assertFalse(serial.isUnsubscribed) - Assert.assertFalse(s0.isUnsubscribed) - Assert.assertFalse(s1.isUnsubscribed) + assertFalse(serial.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) serial.subscription = s0 - Assert.assertFalse(s0.isUnsubscribed) - Assert.assertFalse(s1.isUnsubscribed) + assertFalse(s0.isUnsubscribed) + assertFalse(s1.isUnsubscribed) serial.subscription = s1 - Assert.assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription - Assert.assertFalse(s1.isUnsubscribed) + assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription + assertFalse(s1.isUnsubscribed) serial.unsubscribe() - Assert.assertTrue(serial.isUnsubscribed) - Assert.assertTrue(s1.isUnsubscribed) + assertTrue(serial.isUnsubscribed) + assertTrue(s1.isUnsubscribed) val s2 = Subscription() - Assert.assertFalse(s2.isUnsubscribed) + assertFalse(s2.isUnsubscribed) serial.subscription = s2 - Assert.assertTrue(s2.isUnsubscribed) + assertTrue(s2.isUnsubscribed) } } From 9b7aebfc88fa06ad4e60b216d7c628be7dbfe7a1 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 17:31:53 -0800 Subject: [PATCH 050/441] Cleaned up subscriptions to make them idempotent when called from either side. --- .../main/scala/rx/lang/scala/Scheduler.scala | 11 -------- .../scala/rx/lang/scala/Subscription.scala | 26 +++++++----------- .../subscriptions/BooleanSubscription.scala | 21 +++++++++------ .../subscriptions/SerialSubscription.scala | 27 ++++++++++--------- .../rx/lang/scala/SubscriptionTests.scala | 24 ++++++++++++++++- 5 files changed, 60 insertions(+), 49 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 45d0b44952..146b613237 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -180,17 +180,6 @@ trait Scheduler { work{ t1.call() } } })) - //action1[action0] - -// val subscription = new rx.subscriptions.MultipleAssignmentSubscription() -// -// subscription.setSubscription( -// this.schedule(scheduler => { -// def loop(): Unit = subscription.setSubscription(scheduler.schedule{ work{ loop() }}) -// loop() -// subscription -// })) -// subscription } /** diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index 10271d95fb..f0edaf0d35 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -26,28 +26,24 @@ import java.util.concurrent.atomic.AtomicBoolean */ trait Subscription { - private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { - override def unsubscribe(){ Subscription.this.unsubscribe() } - } - + private [scala] val asJavaSubscription: rx.Subscription + private [scala] val unsubscribed = new AtomicBoolean(false) /** * Call this method to stop receiving notifications on the Observer that was registered when * this Subscription was received. */ - def unsubscribe(): Unit = { unsubscribed.set(true) } + def unsubscribe() = asJavaSubscription.unsubscribe() /** * Checks if the subscription is unsubscribed. */ - def isUnsubscribed: Boolean = unsubscribed.get() - private [scala] val unsubscribed = new AtomicBoolean(false) + def isUnsubscribed = unsubscribed.get() } object Subscription { - /** * Creates an [[rx.lang.scala.Subscription]] from an [[rx.Subscription]]. ß */ @@ -57,24 +53,22 @@ object Subscription { case x: rx.subscriptions.CompositeSubscription => new rx.lang.scala.subscriptions.CompositeSubscription(x) case x: rx.subscriptions.MultipleAssignmentSubscription => new rx.lang.scala.subscriptions.MultipleAssignmentSubscription(x) case x: rx.subscriptions.SerialSubscription => new rx.lang.scala.subscriptions.SerialSubscription(x) - case x: rx.Subscription => apply { x.unsubscribe() } + case x: rx.Subscription => apply{ x.unsubscribe } } } /** * Creates an [[rx.lang.scala.Subscription]] that invokes the specified action when unsubscribed. */ - def apply(u: => Unit): Subscription = { - new Subscription() { - override def unsubscribe(): Unit = { - if(!super.isUnsubscribed) { u; super.unsubscribe() } - } + def apply(u: => Unit): Subscription = new Subscription() { + val asJavaSubscription = new rx.Subscription { + override def unsubscribe() { if(unsubscribed.compareAndSet(false, true)) { u } } } } /** - * Checks if the subscription is unsubscribed. + * Creates an empty [[rx.lang.scala.Subscription]]. */ - def apply(): Subscription = { new Subscription {} } + def apply(): Subscription = Subscription {} } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index a299299f21..cc6551b4cc 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -17,17 +17,22 @@ package rx.lang.scala.subscriptions import rx.lang.scala._ +private [scala] object BooleanSubscription { + def apply(): BooleanSubscription = new BooleanSubscription(new rx.subscriptions.BooleanSubscription()) +} + /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -private [scala] class BooleanSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.BooleanSubscription) +private [scala] class BooleanSubscription private[scala] (boolean: rx.subscriptions.BooleanSubscription) extends Subscription { - //override def asJavaSubscription = subscription - - /** - * Checks whether the subscription has been unsubscribed. - */ - override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed - override def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + val asJavaSubscription: rx.subscriptions.BooleanSubscription = new rx.subscriptions.BooleanSubscription() { + override def unsubscribe(): Unit = { + if(unsubscribed.compareAndSet(false, true)) { + if(!boolean.isUnsubscribed) { boolean.unsubscribe() } + } + } + override def isUnsubscribed(): Boolean = unsubscribed.get() || boolean.isUnsubscribed + } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index 749dadb0c9..43a2836e0a 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -17,38 +17,39 @@ package rx.lang.scala.subscriptions import rx.lang.scala._ - object SerialSubscription { /** * Creates a [[rx.lang.scala.subscriptions.SerialSubscription]]. */ - def apply(): SerialSubscription = { - new SerialSubscription(new rx.subscriptions.SerialSubscription()) - } + def apply(): SerialSubscription = new SerialSubscription(new rx.subscriptions.SerialSubscription()) /** * Creates a [[rx.lang.scala.subscriptions.SerialSubscription]] that invokes the specified action when unsubscribed. */ def apply(unsubscribe: => Unit): SerialSubscription = { - val s= SerialSubscription() - s.subscription = Subscription{ unsubscribe } - s + SerialSubscription().subscription = Subscription(unsubscribe) } } /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class SerialSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.SerialSubscription) extends Subscription { +class SerialSubscription private[scala] (serial: rx.subscriptions.SerialSubscription) extends Subscription { - //override def asJavaSubscription = s - /** - * Unsubscribes this subscription, setting isUnsubscribed to true. + /* + * As long as rx.subscriptions.SerialSubscription has no isUnsubscribed, + * we need to intercept and do it ourselves. */ - override def unsubscribe(): Unit = { asJavaSubscription.unsubscribe(); unsubscribed.set(true) } + val asJavaSubscription: rx.subscriptions.SerialSubscription = new rx.subscriptions.SerialSubscription() { + override def unsubscribe(): Unit = { + if(unsubscribed.compareAndSet(false, true)) { serial.unsubscribe() } + } + override def setSubscription(subscription: rx.Subscription): Unit = serial.setSubscription(subscription) + override def getSubscription(): rx.Subscription = serial.getSubscription() + } - def subscription_=(value: Subscription): Unit = asJavaSubscription.setSubscription(value.asJavaSubscription) + def subscription_=(value: Subscription): this.type = { asJavaSubscription.setSubscription(value.asJavaSubscription); this } def subscription: Subscription = Subscription(asJavaSubscription.getSubscription) } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index a9e9cf6b27..71ea4d4a6e 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -24,11 +24,13 @@ class SubscriptionTests extends JUnitSuite { assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() + assertTrue(subscription.isUnsubscribed) } @Test def subscriptionUnsubscribeIdempotent() { + var called = false val subscription = Subscription{ called = !called } @@ -37,10 +39,12 @@ class SubscriptionTests extends JUnitSuite { assertFalse(subscription.isUnsubscribed) subscription.unsubscribe() + assertTrue(called) assertTrue(subscription.isUnsubscribed) subscription.unsubscribe() + assertTrue(called) assertTrue(subscription.isUnsubscribed) } @@ -62,11 +66,14 @@ class SubscriptionTests extends JUnitSuite { assertTrue(composite.isUnsubscribed) assertTrue(s0.isUnsubscribed) - assertTrue(s0.isUnsubscribed) + assertTrue(s1.isUnsubscribed) val s2 = Subscription{} + assertFalse(s2.isUnsubscribed) + composite += s2 + assertTrue(s2.isUnsubscribed) } @@ -84,7 +91,9 @@ class SubscriptionTests extends JUnitSuite { assertTrue(s0.isUnsubscribed) composite.unsubscribe() + assertTrue(composite.isUnsubscribed) + assertTrue(s0.isUnsubscribed) } @Test @@ -99,21 +108,27 @@ class SubscriptionTests extends JUnitSuite { assertFalse(s1.isUnsubscribed) multiple.subscription = s0 + assertFalse(s0.isUnsubscribed) assertFalse(s1.isUnsubscribed) multiple.subscription = s1 + assertFalse(s0.isUnsubscribed) // difference with SerialSubscription assertFalse(s1.isUnsubscribed) multiple.unsubscribe() + assertTrue(multiple.isUnsubscribed) assertFalse(s0.isUnsubscribed) assertTrue(s1.isUnsubscribed) val s2 = Subscription() + assertFalse(s2.isUnsubscribed) + multiple.subscription = s2 + assertTrue(s2.isUnsubscribed) assertFalse(s0.isUnsubscribed) } @@ -130,20 +145,27 @@ class SubscriptionTests extends JUnitSuite { assertFalse(s1.isUnsubscribed) serial.subscription = s0 + assertFalse(s0.isUnsubscribed) assertFalse(s1.isUnsubscribed) serial.subscription = s1 + assertTrue(s0.isUnsubscribed) // difference with MultipleAssignmentSubscription assertFalse(s1.isUnsubscribed) serial.unsubscribe() + assertTrue(serial.isUnsubscribed) assertTrue(s1.isUnsubscribed) val s2 = Subscription() + assertFalse(s2.isUnsubscribed) + serial.subscription = s2 + assertTrue(s2.isUnsubscribed) } + } From 077ac949cb8bb47d45d3da9460c2f8032b436125 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 17:40:56 -0800 Subject: [PATCH 051/441] Release notes for Notification --- language-adaptors/rxjava-scala/ReleaseNotes.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 7da54a9374..de0541498b 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -146,7 +146,7 @@ Subscriptions ------------- The `Subscription` trait in Scala now has `isUnsubscribed` as a member, effectively collapsing the old `Subscription` -and `BooleanSubscription`, and the latter has been removed from the public surface. Pending a bugfix in RxJava, +and `BooleanSubscription`, and the latter has been removed from the public surface. Pending a bug fix in RxJava, `SerialSubscription` implements its own `isUnsubscribed`. @@ -163,11 +163,11 @@ object Subscription {...} * `Subscription{...}`, `Subscription()` * `CompositeSubscription(subscriptions)` - * `MultipleAssignmentSubscription` - * `SerialSubscription` + * `MultipleAssignmentSubscription()` + * `SerialSubscription()` In case you do feel tempted to call `new Subscription{...}` directly make sure you wire up `isUnsubscribed` - and with the `unsubscribed` field properly, but for all practical purposes you should just use one of the factory methods. + and `unsubscribe()` properly, but for all practical purposes you should just use one of the factory methods. Notifications ------------- @@ -180,7 +180,7 @@ object Notification {...} trait Notification[+T] { override def equals(that: Any): Boolean = {...} override def hashCode(): Int = {...} - def accept[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = {...} + def apply[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = {...} } ``` The nested companion objects of `Notification` now have both constructor (`apply`) and extractor (`unapply`) functions: @@ -194,7 +194,8 @@ object Notification { To construct a `Notification`, you import `rx.lang.scala.Notification._` and use `OnNext("hello")`, or `OnError(new Exception("Oops!"))`, or `OnCompleted()`. -To pattern match on a notification you can create a partial function like so: `case OnNext(v) => { ... v ... }`. +To pattern match on a notification you create a partial function like so: `case Notification.OnNext(v) => { ... v ... }`, +or you use the `apply` function to pass in functions for each possibility. There are no breaking changes for notifications. From a620b5c741debe51ab7b805f53828e24c0a74bc9 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 17:53:02 -0800 Subject: [PATCH 052/441] Layout --- .../rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala | 2 +- .../src/test/scala/rx/lang/scala/SubjectTests.scala | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index 1976285ec6..ad72f49aed 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -74,7 +74,7 @@ object Observer { def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply[T](onNext, (e: Throwable)=>(), onCompleted) def apply[T](n: T=>Unit, e: Throwable=>Unit, c: ()=>Unit): Observer[T] = { // Java calls XXX; Scala receives XXX. - Observer(new rx.Observer[T]{ + Observer(new rx.Observer[T] { def onNext(value: T): Unit = n(value) def onError(error: Throwable): Unit = e(error) def onCompleted(): Unit = c() diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 6a6cadda53..edbf81a42e 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -49,8 +49,8 @@ class SubjectTest extends JUnitSuite { val channel: Subject[Integer] = Subject[Integer]() - val a = channel.subscribe(observerA) - val b = channel.subscribe(observerB) + val a = channel(observerA) + val b = channel(observerB) assertEquals(null, lastA) assertEquals(null, lastB) From bbfc649c9fd90b1af4a197faab953d2558129346 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 17:53:54 -0800 Subject: [PATCH 053/441] added apply(Observer) to Observable[T] trait --- .../src/main/scala/rx/lang/scala/Observable.scala | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 0b92f6f253..165ab71ab9 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -103,9 +103,17 @@ trait Observable[+T] asJavaObservable.subscribe(observer.asJavaObserver) } + /** + * $subscribeObserverMain + * + * @param observer $subscribeObserverParamObserver + * @return $subscribeAllReturn + */ + def apply(observer: Observer[T]): Subscription = subscribe(observer) + /** * $subscribeCallbacksMainNoNotifications - * `` + * * @param onNext $subscribeCallbacksParamOnNext * @return $subscribeAllReturn */ From 4d3ba16731938a660033fe911a52b3fc900b0437 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 18:19:47 -0800 Subject: [PATCH 054/441] Added back private PublishSubject[T] object. --- .../scala/rx/lang/scala/subjects/PublishSubject.scala | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala index 74830e8ca6..4af9221f0a 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala @@ -16,6 +16,10 @@ package rx.lang.scala.subjects import rx.lang.scala.Subject +import rx.subjects -private [scala] class PublishSubject[T] private[scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) - extends Subject[T] {} +private [scala] object PublishSubject { + private [scala] def apply[T](): PublishSubject[T] = return new PublishSubject[T](new subjects.PublishSubject[T]()) +} + +private [scala] class PublishSubject[T] private[scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) extends Subject[T] {} From 9effff07b8aa5b51245c6044cee86c380329f24c Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 20:19:07 -0800 Subject: [PATCH 055/441] Observer cleanup --- .../main/scala/rx/lang/scala/Observable.scala | 22 ++++++++++++- .../main/scala/rx/lang/scala/Observer.scala | 31 +++++++++++-------- .../main/scala/rx/lang/scala/Subject.scala | 8 ++--- .../lang/scala/subjects/PublishSubject.scala | 5 ++- .../scala/rx/lang/scala/SubjectTests.scala | 9 ++++-- 5 files changed, 52 insertions(+), 23 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index ef830095d2..7a33b80e3b 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -19,6 +19,8 @@ package rx.lang.scala import rx.util.functions.FuncN import rx.Observable.OnSubscribeFunc + + /** * The Observable interface that implements the Reactive Pattern. * @@ -1993,6 +1995,10 @@ object Observable { toScalaObservable[T](rx.Observable.from(items.toIterable.asJava)) } + def items[T](items: T*): Observable[T] = { + toScalaObservable[T](rx.Observable.from(items.toIterable.asJava)) + } + /** Returns an Observable emitting the value produced by the Future as its single item. * If the future fails, the Observable will fail as well. * @@ -2022,7 +2028,7 @@ object Observable { * the sequence before it completes. * * @param iterable the source `Iterable` sequence - * @param the type of items in the `Iterable` sequence and the + * @param T the type of items in the `Iterable` sequence and the * type of items to be emitted by the resulting Observable * @return an Observable that emits each item in the source `Iterable` * sequence @@ -2031,6 +2037,20 @@ object Observable { toScalaObservable(rx.Observable.from(iterable.asJava)) } + /** + * + * @param iterable the source `Iterable` sequence + * @param scheduler the scheduler to use + * @tparam T the type of items in the `Iterable` sequence and the + * type of items to be emitted by the resulting Observable + * @return an Observable that emits each item in the source `Iterable` + * sequence + */ + def from[T](iterable: Iterable[T], scheduler: Scheduler): Observable[T] = { + toScalaObservable(rx.Observable.from(iterable.asJava, scheduler.asJavaScheduler)) + } + + /** * Returns an Observable that calls an Observable factory to create its Observable for each * new Observer that subscribes. That is, for each subscriber, the actual Observable is determined diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala index ad72f49aed..6e956dd1a1 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observer.scala @@ -24,7 +24,12 @@ package rx.lang.scala */ trait Observer[-T] { - private [scala] val asJavaObserver: rx.Observer[_ >: T] + // Java calls XXX, Scala receives XXX + private [scala] val asJavaObserver: rx.Observer[_ >: T] = new rx.Observer[T] { + def onNext(value: T): Unit = Observer.this.onNext(value) + def onError(error: Throwable): Unit = Observer.this.onError(error) + def onCompleted(): Unit = Observer.this.onCompleted() + } /** * Provides the Observer with new data. @@ -33,21 +38,21 @@ trait Observer[-T] { * * The [[rx.lang.scala.Observable]] will not call this method again after it calls either `onCompleted` or `onError`. */ - def onNext(value: T): Unit + def onNext(value: T): Unit = {} /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has experienced an error condition. * * If the [[rx.lang.scala.Observable]] calls this method, it will not thereafter call `onNext` or `onCompleted`. */ - def onError(error: Throwable): Unit + def onError(error: Throwable): Unit= {} /** * Notifies the Observer that the [[rx.lang.scala.Observable]] has finished sending push-based notifications. * * The [[rx.lang.scala.Observable]] will not call this method if it calls `onError`. */ - def onCompleted(): Unit + def onCompleted(): Unit = {} } @@ -58,12 +63,11 @@ object Observer { */ private [scala] def apply[T](observer: rx.Observer[T]) : Observer[T] = { new Observer[T] { + override val asJavaObserver = observer - val asJavaObserver = observer - - def onNext(value: T): Unit = asJavaObserver.onNext(value) - def onError(error: Throwable): Unit = asJavaObserver.onError(error) - def onCompleted(): Unit = asJavaObserver.onCompleted() + override def onNext(value: T): Unit = asJavaObserver.onNext(value) + override def onError(error: Throwable): Unit = asJavaObserver.onError(error) + override def onCompleted(): Unit = asJavaObserver.onCompleted() } } @@ -72,12 +76,13 @@ object Observer { def apply[T](onNext: T=>Unit ): Observer[T] = apply[T](onNext, (e: Throwable)=>(), ()=>()) def apply[T](onNext: T=>Unit, onError: Throwable=>Unit ): Observer[T] = apply[T](onNext, onError, ()=>()) def apply[T](onNext: T=>Unit, onCompleted: ()=>Unit): Observer[T] = apply[T](onNext, (e: Throwable)=>(), onCompleted) - def apply[T](n: T=>Unit, e: Throwable=>Unit, c: ()=>Unit): Observer[T] = { + def apply[T](onNext: T=>Unit, onError: Throwable=>Unit, onCompleted: ()=>Unit): Observer[T] = { + val n = onNext; val e = onError; val c = onCompleted // Java calls XXX; Scala receives XXX. Observer(new rx.Observer[T] { - def onNext(value: T): Unit = n(value) - def onError(error: Throwable): Unit = e(error) - def onCompleted(): Unit = c() + override def onNext(value: T): Unit = n(value) + override def onError(error: Throwable): Unit = e(error) + override def onCompleted(): Unit = c() }) } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala index 9bf1500540..5f290404f8 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala @@ -25,10 +25,10 @@ trait Subject[T] extends Observable[T] with Observer[T] { val asJavaObservable: rx.Observable[_ <: T] = asJavaSubject - val asJavaObserver: rx.Observer[_ >: T] = asJavaSubject - def onNext(value: T): Unit = { asJavaObserver.onNext(value)} - def onError(error: Throwable): Unit = { asJavaObserver.onError(error) } - def onCompleted() { asJavaObserver.onCompleted() } + override val asJavaObserver: rx.Observer[_ >: T] = asJavaSubject + override def onNext(value: T): Unit = { asJavaObserver.onNext(value)} + override def onError(error: Throwable): Unit = { asJavaObserver.onError(error) } + override def onCompleted() { asJavaObserver.onCompleted() } } object Subject { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala index 4af9221f0a..129717d8cc 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subjects/PublishSubject.scala @@ -16,10 +16,9 @@ package rx.lang.scala.subjects import rx.lang.scala.Subject -import rx.subjects private [scala] object PublishSubject { - private [scala] def apply[T](): PublishSubject[T] = return new PublishSubject[T](new subjects.PublishSubject[T]()) + def apply[T](): PublishSubject[T] = new PublishSubject[T](rx.subjects.PublishSubject.create[T]()) } -private [scala] class PublishSubject[T] private[scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) extends Subject[T] {} +private [scala] class PublishSubject[T] private [scala] (val asJavaSubject: rx.subjects.PublishSubject[T]) extends Subject[T] {} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index edbf81a42e..d5f7774b1e 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -97,7 +97,7 @@ class SubjectTest extends JUnitSuite { @Test def ReplaySubjectIsAChannel() { - val channel = ReplaySubject[Int] + val channel = ReplaySubject[Integer] var lastA: Integer = null var errorA, completedA: Boolean = false @@ -105,7 +105,12 @@ class SubjectTest extends JUnitSuite { var lastB: Integer = null var errorB, completedB: Boolean = false - val b = channel.subscribe(x => { lastB = x}, e => { errorB = true} , () => { completedB = true }) + + val b = channel(new Observer[Integer] { + override def onNext(value: Integer): Unit = { lastB = value } + override def onError(error: Throwable): Unit = { errorB = true } + override def onCompleted(): Unit = { completedB = true } + }) channel.onNext(42) From 8c8111337130a5cf79d3731cb0a060e5482551c5 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 20:28:30 -0800 Subject: [PATCH 056/441] Added default implementation in Subscription trait --- .../src/main/scala/rx/lang/scala/Subscription.scala | 7 +++++-- .../rx/lang/scala/subscriptions/BooleanSubscription.scala | 2 +- .../rx/lang/scala/subscriptions/SerialSubscription.scala | 2 +- .../src/test/scala/rx/lang/scala/SubjectTests.scala | 2 +- 4 files changed, 8 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala index f0edaf0d35..a5703c682e 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala @@ -26,8 +26,11 @@ import java.util.concurrent.atomic.AtomicBoolean */ trait Subscription { - private [scala] val asJavaSubscription: rx.Subscription private [scala] val unsubscribed = new AtomicBoolean(false) + private [scala] val asJavaSubscription: rx.Subscription = new rx.Subscription { + override def unsubscribe() { unsubscribed.compareAndSet(false, true) } + } + /** * Call this method to stop receiving notifications on the Observer that was registered when @@ -61,7 +64,7 @@ object Subscription { * Creates an [[rx.lang.scala.Subscription]] that invokes the specified action when unsubscribed. */ def apply(u: => Unit): Subscription = new Subscription() { - val asJavaSubscription = new rx.Subscription { + override val asJavaSubscription = new rx.Subscription { override def unsubscribe() { if(unsubscribed.compareAndSet(false, true)) { u } } } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala index cc6551b4cc..d7e0431d27 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala @@ -27,7 +27,7 @@ private [scala] object BooleanSubscription { private [scala] class BooleanSubscription private[scala] (boolean: rx.subscriptions.BooleanSubscription) extends Subscription { - val asJavaSubscription: rx.subscriptions.BooleanSubscription = new rx.subscriptions.BooleanSubscription() { + override val asJavaSubscription: rx.subscriptions.BooleanSubscription = new rx.subscriptions.BooleanSubscription() { override def unsubscribe(): Unit = { if(unsubscribed.compareAndSet(false, true)) { if(!boolean.isUnsubscribed) { boolean.unsubscribe() } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index 43a2836e0a..dfb51cedac 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -41,7 +41,7 @@ class SerialSubscription private[scala] (serial: rx.subscriptions.SerialSubscrip * As long as rx.subscriptions.SerialSubscription has no isUnsubscribed, * we need to intercept and do it ourselves. */ - val asJavaSubscription: rx.subscriptions.SerialSubscription = new rx.subscriptions.SerialSubscription() { + override val asJavaSubscription: rx.subscriptions.SerialSubscription = new rx.subscriptions.SerialSubscription() { override def unsubscribe(): Unit = { if(unsubscribed.compareAndSet(false, true)) { serial.unsubscribe() } } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index d5f7774b1e..9e6e152544 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -98,7 +98,7 @@ class SubjectTest extends JUnitSuite { @Test def ReplaySubjectIsAChannel() { val channel = ReplaySubject[Integer] - + var lastA: Integer = null var errorA, completedA: Boolean = false val a = channel.subscribe(x => { lastA = x}, e => { errorA = true} , () => { completedA = true }) From e9c44768cc17998dfbff6d8c0aac7ab0c8ff87fb Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 20:29:38 -0800 Subject: [PATCH 057/441] Experimental extension methods for lists. --- .../src/main/scala/rx/lang/scala/package.scala | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala index 83352c8426..55a79b8af6 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala @@ -20,4 +20,16 @@ package rx.lang * * It basically mirrors the structure of package `rx`, but some changes were made to make it more Scala-idiomatic. */ -package object scala {} +package object scala { + + /** + * Placeholder for extension methods into Observable[T] from other types + */ + implicit class ObservableExtensions[T](val source: Iterable[T]) extends AnyVal { + def toObservable(): Observable[T] = { Observable.from(source) } + def toObservable(scheduler: Scheduler): Observable[T] = { Observable.from(source, scheduler) } + } + + + +} From 852f55914ff2cefa3eb1ee4a63993f811c602982 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Sun, 8 Dec 2013 20:56:44 -0800 Subject: [PATCH 058/441] Test to show various constructors. --- .../rxjava-scala/ReleaseNotes.md | 37 +++++++------------ .../scala/rx/lang/scala/ConstructorTest.scala | 20 ++++++++++ .../scala/rx/lang/scala/SubjectTests.scala | 1 - 3 files changed, 34 insertions(+), 24 deletions(-) create mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index de0541498b..8a12260251 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -2,7 +2,7 @@ RxScala Release Notes ===================== This release of the RxScala bindings builds on the previous 0.15 release to make the Rx bindings for Scala -include all Rx types. In particular this release focuses on the `Subject` and `Scheduler` types. +include all Rx types. In particular this release focuses on fleshing out the bindings for the `Subject` and `Scheduler` types. To makes these notes self-contained, we will start with the `Observer[T]` and `Observable[T]` traits that lay at the heart of Rx. @@ -10,7 +10,8 @@ Observer -------- In this release we have made the `asJavaObserver` property in `Observable[T]`as well the the factory method in the - companion object that takes an `rx.Observer` private to the Scala bindings package. + companion object that takes an `rx.Observer` private to the Scala bindings package, thus properly hiding irrelevant + implementation details from the user-facing API. The `Observer[T]` trait now looks like a clean, native Scala type: ```scala trait Observer[-T] { @@ -22,13 +23,11 @@ trait Observer[-T] { object Observer {...} ``` -To create an instance of say `Observer[SensorEvent]` in user code, you can create a new instance of the `Observer` trait -and implement any of the methods that you care about: +To create an instance of a specific `Observer`, say `Observer[SensorEvent]` in user code, you can create a new instance +of the `Observer` trait by implementing any of the methods that you care about: ```scala val printObserver = new Observer[SensorEvent] { override def onNext(value: SensorEvent): Unit = {...value.toString...} - override def onError(error: Throwable): Unit = {...} - override def onCompleted(): Unit = {...} } ``` or you can use one of the overloads of the companion `Observer` object by passing in implementations of the `onNext`, @@ -63,7 +62,7 @@ object Observable { The major changes in `Observable` are wrt to the factory methods where too libral use of overloading of the `apply` method hindered type inference and made Scala code look unnecessarily different than that in other language bindings. -In fact the only occurence left of `apply` if for the varargs case. All other factory methods now have their own name. +In fact the only occurrence left of `apply` is for the varargs case. All other factory methods now have their own name. * `def apply[T](items: T*): Observable[T]` * `def from[T](f: Future[T]): Observable[T]` @@ -84,18 +83,8 @@ object Subject { def apply(): Subject[T] = {...} } ``` -For each kind of subject, there is a class with a private constructor and a companion object -that you should use to create a new kind of subject : - -```scala -object XXXSubject { - def apply[T](...): XXXSubject[T] = {...} -} - -class XXXSubject[T] private[scala] (val asJavaSubject: rx.subjects.XXXSubject[T]) extends Subject[T,T] {} -``` - -The subjects that are available are: +For each kind of subject, there is a class with a private constructor and a companion object that you should use +to create a new kind of subject. The subjects that are available are: * `AsyncSubject[T]()` * `BehaviorSubject[T](value)` @@ -105,15 +94,17 @@ The subjects that are available are: The latter is still missing various overloads http://msdn.microsoft.com/en-us/library/hh211810(v=vs.103).aspx which you can expect to appear once they are added to the underlying RxJava implementation. -Compared with release 0.15.1 there are no breaking changes in `Subject` for this release, except for -making `asJavaSubject` private, and collapsing its type parameters. Neither of these should cause trouble. +Compared with release 0.15.1, the breaking changes in `Subject` for this release are +making `asJavaSubject` private, and collapsing its type parameters, neither of these should cause trouble, +and renaming `PublishSubject` to `Subject`. Schedulers ---------- The biggest breaking change compared to the 0.15.1 release is giving `Scheduler` the same structure as the other types. The trait itself remains unchanged, except that we made the underlying Java representation hidden as above. -The scheduler package has been renamed from `rx.lang.scala.concurrency` to `rx.lang.scala.schedulers`. +as part of this reshuffling, the scheduler package has been renamed from `rx.lang.scala.concurrency` +to `rx.lang.scala.schedulers`. There is a high probability that this package renaming will also happen in RxJava. ```scala trait Scheduler {...} @@ -121,7 +112,7 @@ trait Scheduler {...} In the previous release, you created schedulers by selecting them from the `Schedulers` object, as in `Schedulers.immediate` or `Schedulers.newThread` where each would return an instance of the `Scheduler` trait. -However, several of the scheduler implementations have additional methods, such as the `testScheduler`, +However, several of the scheduler implementations have additional methods, such as the `TestScheduler`, which already deviated from the pattern. In this release, we changed this to make scheduler more like `Subject` and provide a family of schedulers diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala new file mode 100644 index 0000000000..2249a47729 --- /dev/null +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala @@ -0,0 +1,20 @@ +package rx.lang.scala +import scala.language.postfixOps +import org.junit.Assert._ +import org.junit.Test +import org.scalatest.junit.JUnitSuite + +class ConstructorTest extends JUnitSuite { + + @Test def toObservable() { + val xs = List(1,2,3).toObservable().toBlockingObservable.toList + assertEquals(List(1,2,3), xs) + + val ys = Observable(List(1,2,3)).toBlockingObservable.toList + assertEquals(List(1,2,3), xs) + + val zs = Observable(1,2,3).toBlockingObservable.toList + assertEquals(List(1,2,3), xs) + + } +} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 9e6e152544..50773d5582 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -15,7 +15,6 @@ import org.junit.Ignore import org.junit.Test import org.scalatest.junit.JUnitSuite - class SubjectTest extends JUnitSuite { @Test def SubjectIsAChannel() { From ba1d44853c2780039d870ee1d347f35f81d3ed79 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Mon, 9 Dec 2013 09:42:50 +0100 Subject: [PATCH 059/441] Lock-free subscriptions --- .../subscriptions/CompositeSubscription.java | 137 ++++++++++-------- .../MultipleAssignmentSubscription.java | 39 +++-- .../subscriptions/RefCountSubscription.java | 106 +++++++++----- .../rx/subscriptions/SerialSubscription.java | 17 ++- .../SingleAssignmentSubscription.java | 10 +- .../MultipleAssignmentSubscriptionTest.java | 68 +++++++++ .../RefCountSubscriptionTest.java | 108 ++++++++++++++ .../SerialSubscriptionTests.java | 4 +- 8 files changed, 369 insertions(+), 120 deletions(-) create mode 100644 rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java create mode 100644 rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java index dd415d887c..c19331c8ec 100644 --- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java +++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java @@ -1,18 +1,18 @@ -/** - * 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. - */ + /** + * 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.subscriptions; import static java.util.Arrays.asList; @@ -20,6 +20,7 @@ import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.HashSet; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; @@ -30,50 +31,60 @@ /** * Subscription that represents a group of Subscriptions that are unsubscribed * together. - * + * * @see Rx.Net * equivalent CompositeDisposable */ public class CompositeSubscription implements Subscription { - private static final Set MUTATE_STATE = unmodifiableSet(new HashSet()); - private static final Set UNSUBSCRIBED_STATE = unmodifiableSet(new HashSet()); - + /** Sentinel to indicate a thread is modifying the subscription set. */ + private static final Set MUTATE_SENTINEL = unmodifiableSet(Collections.emptySet()); + /** Sentinel to indicate the entire CompositeSubscription has been unsubscribed.*/ + private static final Set UNSUBSCRIBED_SENTINEL = unmodifiableSet(Collections.emptySet()); + /** The reference to the set of subscriptions. */ private final AtomicReference> reference = new AtomicReference>(); - + public CompositeSubscription(final Subscription... subscriptions) { reference.set(new HashSet(asList(subscriptions))); } - + public boolean isUnsubscribed() { - return reference.get() == UNSUBSCRIBED_STATE; + return reference.get() == UNSUBSCRIBED_SENTINEL; } - + public void add(final Subscription s) { do { final Set existing = reference.get(); - if (existing == UNSUBSCRIBED_STATE) { + if (existing == UNSUBSCRIBED_SENTINEL) { s.unsubscribe(); break; } - - if (reference.compareAndSet(existing, MUTATE_STATE)) { + + if (existing == MUTATE_SENTINEL) { + continue; + } + + if (reference.compareAndSet(existing, MUTATE_SENTINEL)) { existing.add(s); reference.set(existing); break; } } while (true); } - + public void remove(final Subscription s) { do { final Set subscriptions = reference.get(); - if (subscriptions == UNSUBSCRIBED_STATE) { + if (subscriptions == UNSUBSCRIBED_SENTINEL) { s.unsubscribe(); break; } - - if (reference.compareAndSet(subscriptions, MUTATE_STATE)) { + + if (subscriptions == MUTATE_SENTINEL) { + continue; + } + + if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) { // also unsubscribe from it: // http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable.remove(v=vs.103).aspx subscriptions.remove(s); @@ -83,54 +94,66 @@ public void remove(final Subscription s) { } } while (true); } - + public void clear() { do { final Set subscriptions = reference.get(); - if (subscriptions == UNSUBSCRIBED_STATE) { + if (subscriptions == UNSUBSCRIBED_SENTINEL) { break; } - - if (reference.compareAndSet(subscriptions, MUTATE_STATE)) { + + if (subscriptions == MUTATE_SENTINEL) { + continue; + } + + if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) { final Set copy = new HashSet( subscriptions); subscriptions.clear(); reference.set(subscriptions); - - for (final Subscription subscription : copy) { - subscription.unsubscribe(); - } + + unsubscribeAll(copy); break; } } while (true); } - + /** + * Unsubscribe from the collection of subscriptions. + *

+ * Exceptions thrown by any of the {@code unsubscribe()} methods are + * collected into a {@link CompositeException} and thrown once + * all unsubscriptions have been attempted. + * @param subs the collection of subscriptions + */ + private void unsubscribeAll(Collection subs) { + final Collection es = new ArrayList(); + for (final Subscription s : subs) { + try { + s.unsubscribe(); + } catch (final Throwable e) { + es.add(e); + } + } + if (!es.isEmpty()) { + throw new CompositeException( + "Failed to unsubscribe to 1 or more subscriptions.", es); + } + } @Override public void unsubscribe() { do { final Set subscriptions = reference.get(); - if (subscriptions == UNSUBSCRIBED_STATE) { + if (subscriptions == UNSUBSCRIBED_SENTINEL) { break; } - - if (subscriptions == MUTATE_STATE) { + + if (subscriptions == MUTATE_SENTINEL) { continue; } - - if (reference.compareAndSet(subscriptions, UNSUBSCRIBED_STATE)) { - final Collection es = new ArrayList(); - for (final Subscription s : subscriptions) { - try { - s.unsubscribe(); - } catch (final Throwable e) { - es.add(e); - } - } - if (es.isEmpty()) { - break; - } - throw new CompositeException( - "Failed to unsubscribe to 1 or more subscriptions.", es); + + if (reference.compareAndSet(subscriptions, UNSUBSCRIBED_SENTINEL)) { + unsubscribeAll(subscriptions); + break; } } while (true); } diff --git a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java index 74ed285f77..8fed35fbbf 100644 --- a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java +++ b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java @@ -27,34 +27,41 @@ * @see Rx.Net equivalent MultipleAssignmentDisposable */ public class MultipleAssignmentSubscription implements Subscription { - - private final AtomicBoolean unsubscribed = new AtomicBoolean(false); - private AtomicReference subscription = new AtomicReference(); - + private AtomicReference reference = new AtomicReference(); + /** Sentinel for the unsubscribed state. */ + private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() { + @Override + public void unsubscribe() { + } + }; public boolean isUnsubscribed() { - return unsubscribed.get(); + return reference.get() == UNSUBSCRIBED_SENTINEL; } @Override - public synchronized void unsubscribe() { - unsubscribed.set(true); - Subscription s = getSubscription(); + public void unsubscribe() { + Subscription s = reference.getAndSet(UNSUBSCRIBED_SENTINEL); if (s != null) { s.unsubscribe(); } - } - public synchronized void setSubscription(Subscription s) { - if (unsubscribed.get()) { - s.unsubscribe(); - } else { - subscription.set(s); - } + public void setSubscription(Subscription s) { + do { + Subscription r = reference.get(); + if (r == UNSUBSCRIBED_SENTINEL) { + s.unsubscribe(); + return; + } + if (reference.compareAndSet(r, s)) { + break; + } + } while (true); } public Subscription getSubscription() { - return subscription.get(); + Subscription s = reference.get(); + return s != UNSUBSCRIBED_SENTINEL ? s : Subscriptions.empty(); } } diff --git a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java index bea8c82f1e..a4747caa9b 100644 --- a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java +++ b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java @@ -16,6 +16,8 @@ package rx.subscriptions; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; import rx.Subscription; /** @@ -25,10 +27,24 @@ * @see MSDN RefCountDisposable */ public class RefCountSubscription implements Subscription { - private final Object guard = new Object(); - private Subscription main; - private boolean done; - private int count; + /** The state for the atomic operations. */ + private enum State { + ACTIVE, + MUTATING, + UNSUBSCRIBED + } + /** The reference to the actual subscription. */ + private volatile Subscription main; + /** The current state. */ + private final AtomicReference state = new AtomicReference(); + /** Counts the number of sub-subscriptions. */ + private final AtomicInteger count = new AtomicInteger(); + /** Indicate the request to unsubscribe from the main. */ + private final AtomicBoolean mainDone = new AtomicBoolean(); + /** + * Create a RefCountSubscription by wrapping the given non-null Subscription. + * @param s + */ public RefCountSubscription(Subscription s) { if (s == null) { throw new IllegalArgumentException("s"); @@ -39,54 +55,76 @@ public RefCountSubscription(Subscription s) { * Returns a new sub-subscription. */ public Subscription getSubscription() { - synchronized (guard) { - if (main == null) { + do { + State s = state.get(); + if (s == State.UNSUBSCRIBED) { return Subscriptions.empty(); - } else { - count++; + } + if (s == State.MUTATING) { + continue; + } + if (state.compareAndSet(s, State.MUTATING)) { + count.incrementAndGet(); + state.set(State.ACTIVE); return new InnerSubscription(); } - } + } while(true); } /** * Check if this subscription is already unsubscribed. */ public boolean isUnsubscribed() { - synchronized (guard) { - return main == null; - } + return state.get() == State.UNSUBSCRIBED; } @Override public void unsubscribe() { - Subscription s = null; - synchronized (guard) { - if (main != null && !done) { - done = true; - if (count == 0) { - s = main; - main = null; + do { + State s = state.get(); + if (s == State.UNSUBSCRIBED) { + return; + } + if (s == State.MUTATING) { + continue; + } + if (state.compareAndSet(s, State.MUTATING)) { + if (mainDone.compareAndSet(false, true) && count.get() == 0) { + terminate(); + return; } + state.set(State.ACTIVE); + break; } - } - if (s != null) { - s.unsubscribe(); - } + } while (true); + } + /** + * Terminate this subscription by unsubscribing from main and setting the + * state to UNSUBSCRIBED. + */ + private void terminate() { + state.set(State.UNSUBSCRIBED); + Subscription r = main; + main = null; + r.unsubscribe(); } /** Remove an inner subscription. */ void innerDone() { - Subscription s = null; - synchronized (guard) { - if (main != null) { - count--; - if (done && count == 0) { - s = main; - main = null; + do { + State s = state.get(); + if (s == State.UNSUBSCRIBED) { + return; + } + if (s == State.MUTATING) { + continue; + } + if (state.compareAndSet(s, State.MUTATING)) { + if (count.decrementAndGet() == 0 && mainDone.get()) { + terminate(); + return; } + state.set(State.ACTIVE); + break; } - } - if (s != null) { - s.unsubscribe(); - } + } while (true); } /** The individual sub-subscriptions. */ class InnerSubscription implements Subscription { diff --git a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java index 9aaa3e9a59..e26a258acc 100644 --- a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java +++ b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java @@ -29,22 +29,27 @@ */ public class SerialSubscription implements Subscription { private final AtomicReference reference = new AtomicReference(empty()); - - private static final Subscription UNSUBSCRIBED = new Subscription() { + /** Sentinel for the unsubscribed state. */ + private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() { @Override public void unsubscribe() { } }; - + public boolean isUnsubscribed() { + return reference.get() == UNSUBSCRIBED_SENTINEL; + } @Override public void unsubscribe() { - setSubscription(UNSUBSCRIBED); + Subscription s = reference.getAndSet(UNSUBSCRIBED_SENTINEL); + if (s != null) { + s.unsubscribe(); + } } public void setSubscription(final Subscription subscription) { do { final Subscription current = reference.get(); - if (current == UNSUBSCRIBED) { + if (current == UNSUBSCRIBED_SENTINEL) { subscription.unsubscribe(); break; } @@ -57,6 +62,6 @@ public void setSubscription(final Subscription subscription) { public Subscription getSubscription() { final Subscription subscription = reference.get(); - return subscription == UNSUBSCRIBED ? null : subscription; + return subscription == UNSUBSCRIBED_SENTINEL ? Subscriptions.empty() : subscription; } } diff --git a/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java index ae79bc62a1..c960db2ea4 100644 --- a/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java +++ b/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java @@ -32,7 +32,7 @@ public final class SingleAssignmentSubscription implements Subscription { /** Holds the current resource. */ private final AtomicReference current = new AtomicReference(); /** Sentinel for the unsubscribed state. */ - private static final Subscription SENTINEL = new Subscription() { + private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() { @Override public void unsubscribe() { } @@ -42,7 +42,7 @@ public void unsubscribe() { */ public Subscription get() { Subscription s = current.get(); - if (s == SENTINEL) { + if (s == UNSUBSCRIBED_SENTINEL) { return Subscriptions.empty(); } return s; @@ -57,7 +57,7 @@ public void set(Subscription s) { if (current.compareAndSet(null, s)) { return; } - if (current.get() != SENTINEL) { + if (current.get() != UNSUBSCRIBED_SENTINEL) { throw new IllegalStateException("Subscription already set"); } if (s != null) { @@ -66,7 +66,7 @@ public void set(Subscription s) { } @Override public void unsubscribe() { - Subscription old = current.getAndSet(SENTINEL); + Subscription old = current.getAndSet(UNSUBSCRIBED_SENTINEL); if (old != null) { old.unsubscribe(); } @@ -75,7 +75,7 @@ public void unsubscribe() { * Test if this subscription is already unsubscribed. */ public boolean isUnsubscribed() { - return current.get() == SENTINEL; + return current.get() == UNSUBSCRIBED_SENTINEL; } } diff --git a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java new file mode 100644 index 0000000000..9fbed89153 --- /dev/null +++ b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java @@ -0,0 +1,68 @@ +/** + * 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.subscriptions; + +import junit.framework.Assert; +import org.junit.Before; +import org.junit.Test; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import rx.Subscription; +import static rx.subscriptions.Subscriptions.create; +import rx.util.functions.Action0; + +public class MultipleAssignmentSubscriptionTest { + Action0 unsubscribe; + Subscription s; + @Before + public void before() { + unsubscribe = mock(Action0.class); + s = create(unsubscribe); + } + @Test + public void testNoUnsubscribeWhenReplaced() { + MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription(); + + mas.setSubscription(s); + mas.setSubscription(null); + mas.unsubscribe(); + + verify(unsubscribe, never()).call(); + + } + @Test + public void testUnsubscribeWhenParentUnsubscribes() { + MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription(); + mas.setSubscription(s); + mas.unsubscribe(); + mas.unsubscribe(); + + verify(unsubscribe, times(1)).call(); + + Assert.assertEquals(true, mas.isUnsubscribed()); + } + @Test + public void testUnsubscribedDoesntLeakSentinel() { + MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription(); + + mas.setSubscription(s); + mas.unsubscribe(); + + Assert.assertEquals(true, mas.getSubscription() == Subscriptions.empty()); + } +} \ No newline at end of file diff --git a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java new file mode 100644 index 0000000000..d11899f903 --- /dev/null +++ b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java @@ -0,0 +1,108 @@ +/** + * 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.subscriptions; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.InOrder; +import static org.mockito.Mockito.*; +import rx.Subscription; +import static rx.subscriptions.Subscriptions.create; +import rx.util.functions.Action0; + +public class RefCountSubscriptionTest { + Action0 main; + RefCountSubscription rcs; + @Before + public void before() { + main = mock(Action0.class); + rcs = new RefCountSubscription(create(main)); + } + @Test + public void testImmediateUnsubscribe() { + InOrder inOrder = inOrder(main); + + rcs.unsubscribe(); + + inOrder.verify(main, times(1)).call(); + + rcs.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + @Test + public void testRCSUnsubscribeBeforeClient() { + InOrder inOrder = inOrder(main); + + Subscription s = rcs.getSubscription(); + + rcs.unsubscribe(); + + inOrder.verify(main, never()).call(); + + s.unsubscribe(); + + inOrder.verify(main, times(1)).call(); + + rcs.unsubscribe(); + s.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + + } + @Test + public void testMultipleClientsUnsubscribeFirst() { + InOrder inOrder = inOrder(main); + + Subscription s1 = rcs.getSubscription(); + Subscription s2 = rcs.getSubscription(); + + s1.unsubscribe(); + inOrder.verify(main, never()).call(); + s2.unsubscribe(); + inOrder.verify(main, never()).call(); + + rcs.unsubscribe(); + inOrder.verify(main, times(1)).call(); + + s1.unsubscribe(); + s2.unsubscribe(); + rcs.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + @Test + public void testMultipleClientsMainUnsubscribeFirst() { + InOrder inOrder = inOrder(main); + + Subscription s1 = rcs.getSubscription(); + Subscription s2 = rcs.getSubscription(); + + rcs.unsubscribe(); + inOrder.verify(main, never()).call(); + s1.unsubscribe(); + inOrder.verify(main, never()).call(); + s2.unsubscribe(); + + inOrder.verify(main, times(1)).call(); + + s1.unsubscribe(); + s2.unsubscribe(); + rcs.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } +} diff --git a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java index 1569d9c7df..4afadb6f9c 100644 --- a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java +++ b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java @@ -49,11 +49,11 @@ public void unsubscribingWithoutUnderlyingDoesNothing() { } @Test - public void getSubscriptionShouldReturnSubscriptionAfterUnsubscribe() { + public void getSubscriptionShouldReturnEmptySubscriptionAfterUnsubscribe() { final Subscription underlying = mock(Subscription.class); serialSubscription.setSubscription(underlying); serialSubscription.unsubscribe(); - assertEquals(null, serialSubscription.getSubscription()); + assertEquals(Subscriptions.empty(), serialSubscription.getSubscription()); } @Test From 5d94e52679110fde7fe5bf04f8514c371e26b538 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Mon, 9 Dec 2013 15:40:30 +0800 Subject: [PATCH 060/441] Implement the 'Start' operator --- rxjava-core/src/main/java/rx/Observable.java | 74 +++++++++++++++++++ .../src/test/java/rx/ObservableTests.java | 65 ++++++++++++++++ 2 files changed, 139 insertions(+) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index cf92fb12cd..1eaa75611d 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -118,6 +118,7 @@ import rx.util.Timestamped; import rx.util.functions.Action0; import rx.util.functions.Action1; +import rx.util.functions.Async; import rx.util.functions.Func0; import rx.util.functions.Func1; import rx.util.functions.Func2; @@ -6269,4 +6270,77 @@ public Observable> groupByUntil(Fun public Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) { return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector)); } + + /** + * Invokes the action asynchronously, surfacing the result through an observable sequence. + *

+ * Note: The action is called immediately, not during the subscription of the resulting + * sequence. Multiple subscriptions to the resulting sequence can observe the + * action's outcome. + * + * @param action + * Action to run asynchronously. + * @return An observable sequence exposing a null value upon completion of the action, + * or an exception. + * @see MSDN: Observable.Start + */ + public static Observable start(Action0 action) { + return Async.toAsync(action).call(); + } + + /** + * Invokes the action asynchronously on the specified scheduler, surfacing the + * result through an observable sequence. + *

+ * Note: The action is called immediately, not during the subscription of the resulting + * sequence. Multiple subscriptions to the resulting sequence can observe the + * action's outcome. + * + * @param action + * Action to run asynchronously. + * @param scheduler + * Scheduler to run the function on. + * @return An observable sequence exposing a null value upon completion of the action, + * or an exception. + * @see MSDN: Observable.Start + */ + public static Observable start(Action0 action, Scheduler scheduler) { + return Async.toAsync(action, scheduler).call(); + } + + /** + * Invokes the specified function asynchronously, surfacing the result through an observable sequence. + *

+ * Note: The function is called immediately, not during the subscription of the resulting + * sequence. Multiple subscriptions to the resulting sequence can observe the + * function's result. + * + * @param func + * Function to run asynchronously. + * @return An observable sequence exposing the function's result value, or an exception. + * @see MSDN: Observable.Start + */ + public static Observable start(Func0 func) { + return Async.toAsync(func).call(); + } + + /** + * Invokes the specified function asynchronously on the specified scheduler, surfacing + * the result through an observable sequence. + *

+ * Note: The function is called immediately, not during the subscription of the resulting + * sequence. Multiple subscriptions to the resulting sequence can observe the + * function's result. + * + * @param func + * Function to run asynchronously. + * @param scheduler + * Scheduler to run the function on. + * @return An observable sequence exposing the function's result value, or an exception. + * @see MSDN: Observable.Start + */ + public static Observable start(Func0 func, Scheduler scheduler) { + return Async.toAsync(func, scheduler).call(); + } + } diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index e4023f44ab..50661238b6 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -33,6 +33,8 @@ import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; import rx.Observable.OnSubscribeFunc; import rx.concurrency.TestScheduler; @@ -41,6 +43,7 @@ import rx.subscriptions.Subscriptions; 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; @@ -947,4 +950,66 @@ public void testRangeWithScheduler() { inOrder.verify(aObserver, times(1)).onCompleted(); inOrder.verifyNoMoreInteractions(); } + + @Test + public void testStartWithAction() { + TestScheduler scheduler = new TestScheduler(); + + Action0 action = mock(Action0.class); + Observable observable = Observable.start(action, scheduler); + scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); + + assertEquals(null, observable.toBlockingObservable().single()); + assertEquals(null, observable.toBlockingObservable().single()); + verify(action, times(1)).call(); + } + + @Test(expected = RuntimeException.class) + public void testStartWithActionError() { + Action0 action = new Action0() { + @Override + public void call() { + throw new RuntimeException("Some error"); + } + }; + + Observable observable = Observable.start(action); + observable.toBlockingObservable().single(); + } + + @Test + public void testStartWithFunc() { + TestScheduler scheduler = new TestScheduler(); + + @SuppressWarnings("unchecked") + Func0 func = (Func0) mock(Func0.class); + doAnswer(new Answer() { + + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + return "one"; + } + + }).when(func).call(); + + Observable observable = Observable.start(func, scheduler); + scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); + + assertEquals("one", observable.toBlockingObservable().single()); + assertEquals("one", observable.toBlockingObservable().single()); + verify(func, times(1)).call(); + } + + @Test(expected = RuntimeException.class) + public void testStartWithFuncError() { + Func0 func = new Func0() { + @Override + public String call() { + throw new RuntimeException("Some error"); + } + }; + + Observable observable = Observable.start(func); + observable.toBlockingObservable().single(); + } } \ No newline at end of file From f7564f60f195541f2ead4743a3f3d77ea65ac046 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Mon, 9 Dec 2013 19:07:16 +0100 Subject: [PATCH 061/441] Fix for buffer not stopping when unsubscribed. --- .../java/rx/operators/ChunkedOperation.java | 18 +++++- .../java/rx/operators/OperationBuffer.java | 60 ++++++++++++++++--- .../rx/operators/OperationBufferTest.java | 24 ++++++++ 3 files changed, 91 insertions(+), 11 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java index 1d3b762891..58f908feef 100644 --- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java +++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java @@ -148,7 +148,7 @@ public OverlappingChunks(Observer observer, Func0 The type of object being tracked by the {@link Chunk} */ - protected static class TimeAndSizeBasedChunks extends Chunks { + protected static class TimeAndSizeBasedChunks extends Chunks implements Subscription { private final ConcurrentMap, Subscription> subscriptions = new ConcurrentHashMap, Subscription>(); @@ -207,6 +207,12 @@ public void pushValue(T value) { } } } + @Override + public void unsubscribe() { + for (Subscription s : subscriptions.values()) { + s.unsubscribe(); + } + } } /** @@ -218,7 +224,7 @@ public void pushValue(T value) { * The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record. * The type of object being tracked by the {@link Chunk} */ - protected static class TimeBasedChunks extends OverlappingChunks { + protected static class TimeBasedChunks extends OverlappingChunks implements Subscription { private final ConcurrentMap, Subscription> subscriptions = new ConcurrentHashMap, Subscription>(); @@ -250,6 +256,14 @@ public void emitChunk(Chunk chunk) { subscriptions.remove(chunk); super.emitChunk(chunk); } + + @Override + public void unsubscribe() { + for (Subscription s : subscriptions.values()) { + s.unsubscribe(); + } + } + } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java index 02d0ce4573..72cc1df211 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java +++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; import rx.Observable; import rx.Observable.OnSubscribeFunc; @@ -24,6 +25,7 @@ import rx.Scheduler; import rx.Subscription; import rx.concurrency.Schedulers; +import rx.subscriptions.CompositeSubscription; import rx.util.functions.Func0; import rx.util.functions.Func1; @@ -65,11 +67,14 @@ public static OnSubscribeFunc> buffer(final Observable public Subscription onSubscribe(Observer> observer) { NonOverlappingChunks> buffers = new NonOverlappingChunks>(observer, OperationBuffer. bufferMaker()); ChunkCreator creator = new ObservableBasedSingleChunkCreator, TClosing>(buffers, bufferClosingSelector); - return source.subscribe(new ChunkObserver>(buffers, observer, creator)); + return new CompositeSubscription( + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(buffers, observer, creator)) + ); } }; } - + /** *

This method creates a {@link Func1} object which represents the buffer operation. This operation takes * values from the specified {@link Observable} source and stores them in the currently active chunks. Initially @@ -101,7 +106,10 @@ public static OnSubscribeFunc> buffer(final Obse public Subscription onSubscribe(final Observer> observer) { OverlappingChunks> buffers = new OverlappingChunks>(observer, OperationBuffer. bufferMaker()); ChunkCreator creator = new ObservableBasedMultiChunkCreator, TOpening, TClosing>(buffers, bufferOpenings, bufferClosingSelector); - return source.subscribe(new ChunkObserver>(buffers, observer, creator)); + return new CompositeSubscription( + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(buffers, observer, creator)) + ); } }; } @@ -156,7 +164,10 @@ public static OnSubscribeFunc> buffer(final Observable source, fi public Subscription onSubscribe(final Observer> observer) { Chunks> chunks = new SizeBasedChunks>(observer, OperationBuffer. bufferMaker(), count); ChunkCreator creator = new SkippingChunkCreator>(chunks, skip); - return source.subscribe(new ChunkObserver>(chunks, observer, creator)); + return new CompositeSubscription( + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(chunks, observer, creator)) + ); } }; } @@ -211,7 +222,10 @@ public static OnSubscribeFunc> buffer(final Observable source, fi public Subscription onSubscribe(final Observer> observer) { NonOverlappingChunks> buffers = new NonOverlappingChunks>(observer, OperationBuffer. bufferMaker()); ChunkCreator creator = new TimeBasedChunkCreator>(buffers, timespan, unit, scheduler); - return source.subscribe(new ChunkObserver>(buffers, observer, creator)); + return new CompositeSubscription( + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(buffers, observer, creator)) + ); } }; } @@ -270,9 +284,13 @@ public static OnSubscribeFunc> buffer(final Observable source, fi return new OnSubscribeFunc>() { @Override public Subscription onSubscribe(final Observer> observer) { - Chunks> chunks = new TimeAndSizeBasedChunks>(observer, OperationBuffer. bufferMaker(), count, timespan, unit, scheduler); + TimeAndSizeBasedChunks> chunks = new TimeAndSizeBasedChunks>(observer, OperationBuffer. bufferMaker(), count, timespan, unit, scheduler); ChunkCreator creator = new SingleChunkCreator>(chunks); - return source.subscribe(new ChunkObserver>(chunks, observer, creator)); + return new CompositeSubscription( + chunks, + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(chunks, observer, creator)) + ); } }; } @@ -331,9 +349,13 @@ public static OnSubscribeFunc> buffer(final Observable source, fi return new OnSubscribeFunc>() { @Override public Subscription onSubscribe(final Observer> observer) { - OverlappingChunks> buffers = new TimeBasedChunks>(observer, OperationBuffer. bufferMaker(), timespan, unit, scheduler); + TimeBasedChunks> buffers = new TimeBasedChunks>(observer, OperationBuffer. bufferMaker(), timespan, unit, scheduler); ChunkCreator creator = new TimeBasedChunkCreator>(buffers, timeshift, unit, scheduler); - return source.subscribe(new ChunkObserver>(buffers, observer, creator)); + return new CompositeSubscription( + buffers, + new ChunkToSubscription(creator), + source.subscribe(new ChunkObserver>(buffers, observer, creator)) + ); } }; } @@ -355,4 +377,24 @@ public List getContents() { return contents; } } + + /** + * Converts a chunk creator into a subscription which stops the chunk. + */ + private static class ChunkToSubscription implements Subscription { + private ChunkCreator cc; + private final AtomicBoolean done; + public ChunkToSubscription(ChunkCreator cc) { + this.cc = cc; + this.done = new AtomicBoolean(); + } + @Override + public void unsubscribe() { + if (done.compareAndSet(false, true)) { + ChunkCreator cc0 = cc; + cc = null; + cc0.stop(); + } + } + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java index 475326a622..a2de69ed63 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java @@ -19,6 +19,7 @@ import static rx.operators.OperationBuffer.*; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -27,6 +28,8 @@ import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mockito; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; import rx.Observable; import rx.Observer; @@ -359,4 +362,25 @@ public void call() { } }, delay, TimeUnit.MILLISECONDS); } + + @Test + public void testBufferStopsWhenUnsubscribed1() { + Observable source = Observable.never(); + + Observer> o = mock(Observer.class); + + Subscription s = source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler).subscribe(o); + + InOrder inOrder = Mockito.inOrder(o); + + scheduler.advanceTimeBy(1001, TimeUnit.MILLISECONDS); + + inOrder.verify(o, times(5)).onNext(Arrays.asList()); + + s.unsubscribe(); + + scheduler.advanceTimeBy(999, TimeUnit.MILLISECONDS); + + inOrder.verifyNoMoreInteractions(); + } } From 2b05109a01acd7173964d8a1d77ae7532c892044 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 10:08:55 -0800 Subject: [PATCH 062/441] Made rx.Scheduler bindings private [scala] such that you can access them them if needed. --- .../src/main/scala/rx/lang/scala/Scheduler.scala | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 146b613237..8b4edde4fa 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -45,7 +45,7 @@ trait Scheduler { * @param action Action to schedule. * @return a subscription to be able to unsubscribe from action. */ - private def schedule[T](state: T, action: (Scheduler, T) => Subscription): Subscription = { + private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription): Subscription = { Subscription(asJavaScheduler.schedule(state, new Func2[rx.Scheduler, T, rx.Subscription] { def call(t1: rx.Scheduler, t2: T): rx.Subscription = { action(Scheduler(t1), t2).asJavaSubscription @@ -75,7 +75,7 @@ trait Scheduler { * Time the action is to be delayed before executing. * @return a subscription to be able to unsubscribe from action. */ - private def schedule[T](state: T, action: (Scheduler, T) => Subscription, delayTime: Duration): Subscription = { + private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription, delayTime: Duration): Subscription = { Subscription(asJavaScheduler.schedule(state, schedulerActionToFunc2(action), delayTime.length, delayTime.unit)) } @@ -108,7 +108,7 @@ trait Scheduler { * The time interval to wait each time in between executing the action. * @return A subscription to be able to unsubscribe from action. */ - private def schedulePeriodically[T](state: T, action: (Scheduler, T) => Subscription, initialDelay: Duration, period: Duration): Subscription = { + private [scala] def schedulePeriodically[T](state: T, action: (Scheduler, T) => Subscription, initialDelay: Duration, period: Duration): Subscription = { Subscription(asJavaScheduler.schedulePeriodically(state, action, initialDelay.length, initialDelay.unit.convert(period.length, period.unit), initialDelay.unit)) } @@ -134,7 +134,7 @@ trait Scheduler { * Time the action is to be executed. If in the past it will be executed immediately. * @return a subscription to be able to unsubscribe from action. */ - private def schedule[T](state: T, action: (Scheduler, T) => Subscription, dueTime: Date): Subscription = { + private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription, dueTime: Date): Subscription = { Subscription(asJavaScheduler.schedule(state, action, dueTime)) } From 9979fa7438f4cf93951d98febba25b81938649d3 Mon Sep 17 00:00:00 2001 From: David Gross Date: Mon, 9 Dec 2013 13:04:58 -0800 Subject: [PATCH 063/441] * corrects grammar of sequenceEqual() javadoc * updates link to wiki description of count() * adds sample(sampler) marble diagram/wiki link * adds longCount() marble diagram/wiki link --- rxjava-core/src/main/java/rx/Observable.java | 22 +++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index b4973fad89..33e451d3d1 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -2297,7 +2297,7 @@ public static Observable from(Future future, long timeout, T } /** - * Returns an Observable that emits a Boolean value that indicate + * Returns an Observable that emits a Boolean value that indicates * whether two sequences are equal by comparing the elements pairwise. *

* @@ -2305,8 +2305,8 @@ public static Observable from(Future future, long timeout, T * @param first the first Observable to compare * @param second the second Observable to compare * @param the type of items emitted by each Observable - * @return an Observable that emits a Boolean value that indicate - * whether two sequences are equal by comparing the elements pairwise. + * @return an Observable that emits a Boolean value that indicates + * whether two sequences are equal by comparing the elements pairwise * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second) { @@ -2322,7 +2322,7 @@ public Boolean call(T first, T second) { } /** - * Returns an Observable that emits a Boolean value that indicate + * Returns an Observable that emits a Boolean value that indicates * whether two sequences are equal by comparing the elements pairwise * based on the results of a specified equality function. *

@@ -2333,8 +2333,8 @@ public Boolean call(T first, T second) { * @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 a Boolean value that indicate - * whether two sequences are equal by comparing the elements pairwise. + * @return an Observable that emits a Boolean value that indicates + * whether two sequences are equal by comparing the elements pairwise * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second, Func2 equality) { @@ -3871,7 +3871,7 @@ public Observable reduce(Func2 accumulator) { * * @return an Observable that emits the number of counted elements of the * source Observable as its single item - * @see RxJava Wiki: count() + * @see RxJava Wiki: count() * @see MSDN: Observable.Count * @see #longCount() */ @@ -4475,12 +4475,14 @@ public Observable sample(long period, TimeUnit unit, Scheduler scheduler) { * Return an Observable that emits the results of sampling the items * emitted by this Observable when the sampler * Observable produces an item or completes. + *

+ * * * @param sampler the Observable to use for sampling this - * * @return an Observable that emits the results of sampling the items * emitted by this Observable when the sampler * Observable produces an item or completes. + * @see RxJava Wiki: sample() */ public Observable sample(Observable sampler) { return create(new OperationSample.SampleWithObservable(this, sampler)); @@ -5198,11 +5200,11 @@ public Observable last() { * Returns an Observable that counts the total number of items in the * source Observable as a 64 bit long. *

- * + * * * @return an Observable that emits the number of counted elements of the * source Observable as its single, 64 bit long item - * @see RxJava Wiki: count() + * @see RxJava Wiki: count() * @see MSDN: Observable.LongCount * @see #count() */ From eec26ae8641c076bc4b97da974080b75b6e24438 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 16:02:04 -0800 Subject: [PATCH 064/441] Empty subscribe() --- .../src/main/scala/rx/lang/scala/Observable.scala | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index 7a33b80e3b..d777a91700 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -83,6 +83,15 @@ trait Observable[+T] private [scala] val asJavaObservable: rx.Observable[_ <: T] + /** + * $subscribeObserverMain + * + * @return $subscribeAllReturn + */ + def subscribe(): Subscription = { + asJavaObservable.subscribe() + } + /** * $subscribeObserverMain * @@ -111,6 +120,7 @@ trait Observable[+T] * @return $subscribeAllReturn */ def apply(observer: Observer[T]): Subscription = subscribe(observer) + def apply(): Subscription = subscribe() /** * $subscribeCallbacksMainNoNotifications From 83b0760b449503adf82d90d96596c729e019ec99 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 18:12:25 -0800 Subject: [PATCH 065/441] Added accept with Observer to match RxJava --- .../scala/rx/lang/scala/Notification.scala | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala index de5839a4d0..616fff22c2 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala @@ -37,13 +37,32 @@ sealed trait Notification[+T] { * @param onCompleted * The function to invoke for an [[rx.lang.scala.Notification.OnCompleted]] notification. */ - def apply[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = { + def accept[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = { this match { case Notification.OnNext(value) => onNext(value) case Notification.OnError(error) => onError(error) case Notification.OnCompleted() => onCompleted() } } + + def apply[R](onNext: T=>R, onError: Throwable=>R, onCompleted: ()=>R): R = + accept(onNext, onError, onCompleted) + + /** + * Invokes the observer corresponding to the notification + * + * @param observer + * The observer that to observe the notification + */ + def accept(observer: Observer[T]): Unit = { + this match { + case Notification.OnNext(value) => observer.onNext(value) + case Notification.OnError(error) => observer.onError(error) + case Notification.OnCompleted() => observer.onCompleted() + } + } + + def apply(observer: Observer[T]): Unit = accept(observer) } /** From 335ec87201b14125d078d9c57e7fd51f658acb75 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 20:23:58 -0800 Subject: [PATCH 066/441] Renamed apply(items: T*) to items. Fixed all tests. --- .../rxjava-scala/ReleaseNotes.md | 16 +++- .../rx/lang/scala/examples/Olympics.scala | 14 ++-- .../rx/lang/scala/examples/RxScalaDemo.scala | 82 +++++++++---------- .../main/scala/rx/lang/scala/Observable.scala | 49 +++++++++-- .../main/scala/rx/lang/scala/package.scala | 2 +- .../scala/rx/lang/scala/ConstructorTest.scala | 6 +- .../scala/rx/lang/scala/ObservableTest.scala | 8 +- 7 files changed, 111 insertions(+), 66 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 8a12260251..659022da8e 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -62,13 +62,21 @@ object Observable { The major changes in `Observable` are wrt to the factory methods where too libral use of overloading of the `apply` method hindered type inference and made Scala code look unnecessarily different than that in other language bindings. -In fact the only occurrence left of `apply` is for the varargs case. All other factory methods now have their own name. +All factory methods now have their own name corresponding to the Java and .NET operators +(plus overloads that take a `Scheduler`). -* `def apply[T](items: T*): Observable[T]` -* `def from[T](f: Future[T]): Observable[T]` +* `def from[T](future: Future[T]): Observable[T]` * `def from[T](iterable: Iterable[T]): Observable[T]` -* `def create[T](subscribe: Observer[T] => Subscription): Observable[T]` * `def error[T](exception: Throwable): Observable[T]` +* `def empty[T]: Observable[T]` +* `def items[T](items: T*): Observable[T] + +In the *pre-release* of this version, we expose both `apply` and `create` for the mother of all creation functions. +We would like to solicit feedback which of these two names is preferred +(or both, but there is a high probability that only one will be chosen). + +* `def apply[T](subscribe: Observer[T]=>Subscription): Observable[T]` +* `def create[T](subscribe: Observer[T] => Subscription): Observable[T]` Subject ------- diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala index 7a11bdf539..ceea9c3b8e 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala @@ -21,8 +21,8 @@ import scala.concurrent.duration._ object Olympics { case class Medal(val year: Int, val games: String, val discipline: String, val medal: String, val athlete: String, val country: String) - def mountainBikeMedals: Observable[Medal] = Observable( - Observable( + def mountainBikeMedals: Observable[Medal] = Observable.items( + Observable.items( Medal(1996, "Atlanta 1996", "cross-country men", "Gold", "Bart BRENTJENS", "Netherlands"), Medal(1996, "Atlanta 1996", "cross-country women", "Gold", "Paola PEZZO", "Italy"), Medal(1996, "Atlanta 1996", "cross-country men", "Silver", "Thomas FRISCHKNECHT", "Switzerland"), @@ -31,7 +31,7 @@ object Olympics { Medal(1996, "Atlanta 1996", "cross-country women", "Bronze", "Susan DEMATTEI", "United States of America") ), fourYearsEmpty, - Observable( + Observable.items( Medal(2000, "Sydney 2000", "cross-country women", "Gold", "Paola PEZZO", "Italy"), Medal(2000, "Sydney 2000", "cross-country women", "Silver", "Barbara BLATTER", "Switzerland"), Medal(2000, "Sydney 2000", "cross-country women", "Bronze", "Marga FULLANA", "Spain"), @@ -40,7 +40,7 @@ object Olympics { Medal(2000, "Sydney 2000", "cross-country men", "Bronze", "Christoph SAUSER", "Switzerland") ), fourYearsEmpty, - Observable( + Observable.items( Medal(2004, "Athens 2004", "cross-country men", "Gold", "Julien ABSALON", "France"), Medal(2004, "Athens 2004", "cross-country men", "Silver", "Jose Antonio HERMIDA RAMOS", "Spain"), Medal(2004, "Athens 2004", "cross-country men", "Bronze", "Bart BRENTJENS", "Netherlands"), @@ -49,7 +49,7 @@ object Olympics { Medal(2004, "Athens 2004", "cross-country women", "Bronze", "Sabine SPITZ", "Germany") ), fourYearsEmpty, - Observable( + Observable.items( Medal(2008, "Beijing 2008", "cross-country women", "Gold", "Sabine SPITZ", "Germany"), Medal(2008, "Beijing 2008", "cross-country women", "Silver", "Maja WLOSZCZOWSKA", "Poland"), Medal(2008, "Beijing 2008", "cross-country women", "Bronze", "Irina KALENTYEVA", "Russian Federation"), @@ -58,7 +58,7 @@ object Olympics { Medal(2008, "Beijing 2008", "cross-country men", "Bronze", "Nino SCHURTER", "Switzerland") ), fourYearsEmpty, - Observable( + Observable.items( Medal(2012, "London 2012", "cross-country men", "Gold", "Jaroslav KULHAVY", "Czech Republic"), Medal(2012, "London 2012", "cross-country men", "Silver", "Nino SCHURTER", "Switzerland"), Medal(2012, "London 2012", "cross-country men", "Bronze", "Marco Aurelio FONTANA", "Italy"), @@ -80,7 +80,7 @@ object Olympics { // So we don't use this: // Observable.interval(fourYears).take(1).map(i => neverUsedDummyMedal).filter(m => false) // But we just return empty, which completes immediately - Observable() + Observable.empty[Medal] } } \ No newline at end of file diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala index ae041512d2..7bf832f58e 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala @@ -75,8 +75,8 @@ class RxScalaDemo extends JUnitSuite { } @Test def testObservableComparison() { - val first = Observable(10, 11, 12) - val second = Observable(10, 11, 12) + val first = Observable.from(List(10, 11, 12)) + val second = Observable.from(List(10, 11, 12)) val b1 = (first zip second) map (p => p._1 == p._2) forall (b => b) @@ -88,8 +88,8 @@ class RxScalaDemo extends JUnitSuite { } @Test def testObservableComparisonWithForComprehension() { - val first = Observable(10, 11, 12) - val second = Observable(10, 11, 12) + val first = Observable.from(List(10, 11, 12)) + val second = Observable.from(List(10, 11, 12)) val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2) @@ -99,8 +99,8 @@ class RxScalaDemo extends JUnitSuite { } @Test def testStartWithIsUnnecessary() { - val before = Observable(-2, -1, 0) - val source = Observable(1, 2, 3) + val before = List(-2, -1, 0).toObservable + val source = List(1, 2, 3).toObservable println((before ++ source).toBlockingObservable.toList) } @@ -124,11 +124,11 @@ class RxScalaDemo extends JUnitSuite { @Test def fattenSomeExample() { // To merge some observables which are all known already: - Observable( + List( Observable.interval(200 millis), Observable.interval(400 millis), Observable.interval(800 millis) - ).flatten.take(12).toBlockingObservable.foreach(println(_)) + ).toObservable.flatten.take(12).toBlockingObservable.foreach(println(_)) } @Test def rangeAndBufferExample() { @@ -143,7 +143,7 @@ class RxScalaDemo extends JUnitSuite { } @Test def testReduce() { - assertEquals(10, Observable(1, 2, 3, 4).reduce(_ + _).toBlockingObservable.single) + assertEquals(10, List(1, 2, 3, 4).toObservable.reduce(_ + _).toBlockingObservable.single) } @Test def testForeach() { @@ -157,7 +157,7 @@ class RxScalaDemo extends JUnitSuite { } @Test def testForComprehension() { - val observables = Observable(Observable(1, 2, 3), Observable(10, 20, 30)) + val observables = List(List(1, 2, 3).toObservable, List(10, 20, 30).toObservable).toObservable val squares = (for (o <- observables; i <- o if i % 2 == 0) yield i*i) assertEquals(squares.toBlockingObservable.toList, List(4, 100, 400, 900)) } @@ -185,14 +185,14 @@ class RxScalaDemo extends JUnitSuite { } @Test def testGroupByThenFlatMap() { - val m = Observable(1, 2, 3, 4) + val m = List(1, 2, 3, 4).toObservable val g = m.groupBy(i => i % 2) val t = g.flatMap((p: (Int, Observable[Int])) => p._2) assertEquals(List(1, 2, 3, 4), t.toBlockingObservable.toList) } @Test def testGroupByThenFlatMapByForComprehension() { - val m = Observable(1, 2, 3, 4) + val m = List(1, 2, 3, 4).toObservable val g = m.groupBy(i => i % 2) val t = for ((i, o) <- g; n <- o) yield n assertEquals(List(1, 2, 3, 4), t.toBlockingObservable.toList) @@ -250,13 +250,13 @@ class RxScalaDemo extends JUnitSuite { } @Test def exampleWithoutPublish() { - val unshared = Observable(1 to 4) + val unshared = List(1 to 4).toObservable unshared.subscribe(n => println(s"subscriber 1 gets $n")) unshared.subscribe(n => println(s"subscriber 2 gets $n")) } @Test def exampleWithPublish() { - val unshared = Observable(1 to 4) + val unshared = List(1 to 4).toObservable val (startFunc, shared) = unshared.publish shared.subscribe(n => println(s"subscriber 1 gets $n")) shared.subscribe(n => println(s"subscriber 2 gets $n")) @@ -288,9 +288,9 @@ class RxScalaDemo extends JUnitSuite { } @Test def testSingleOption() { - assertEquals(None, Observable(1, 2).toBlockingObservable.singleOption) - assertEquals(Some(1), Observable(1) .toBlockingObservable.singleOption) - assertEquals(None, Observable() .toBlockingObservable.singleOption) + assertEquals(None, List(1, 2).toObservable.toBlockingObservable.singleOption) + assertEquals(Some(1), List(1).toObservable.toBlockingObservable.singleOption) + assertEquals(None, List().toObservable.toBlockingObservable.singleOption) } // We can't put a general average method into Observable.scala, because Scala's Numeric @@ -301,58 +301,58 @@ class RxScalaDemo extends JUnitSuite { } @Test def averageExample() { - println(doubleAverage(Observable()).toBlockingObservable.single) - println(doubleAverage(Observable(0)).toBlockingObservable.single) - println(doubleAverage(Observable(4.44)).toBlockingObservable.single) - println(doubleAverage(Observable(1, 2, 3.5)).toBlockingObservable.single) + println(doubleAverage(Observable.empty[Double]).toBlockingObservable.single) + println(doubleAverage(List(0.0).toObservable).toBlockingObservable.single) + println(doubleAverage(List(4.44).toObservable).toBlockingObservable.single) + println(doubleAverage(List(1, 2, 3.5).toObservable).toBlockingObservable.single) } @Test def testSum() { - assertEquals(10, Observable(1, 2, 3, 4).sum.toBlockingObservable.single) - assertEquals(6, Observable(4, 2).sum.toBlockingObservable.single) - assertEquals(0, Observable[Int]().sum.toBlockingObservable.single) + assertEquals(10, List(1, 2, 3, 4).toObservable.sum.toBlockingObservable.single) + assertEquals(6, List(4, 2).toObservable.sum.toBlockingObservable.single) + assertEquals(0, List[Int]().toObservable.sum.toBlockingObservable.single) } @Test def testProduct() { - assertEquals(24, Observable(1, 2, 3, 4).product.toBlockingObservable.single) - assertEquals(8, Observable(4, 2).product.toBlockingObservable.single) - assertEquals(1, Observable[Int]().product.toBlockingObservable.single) + assertEquals(24, List(1, 2, 3, 4).toObservable.product.toBlockingObservable.single) + assertEquals(8, List(4, 2).toObservable.product.toBlockingObservable.single) + assertEquals(1, List[Int]().toObservable.product.toBlockingObservable.single) } @Test def mapWithIndexExample() { // We don't need mapWithIndex because we already have zipWithIndex, which we can easily // combine with map: - Observable("a", "b", "c").zipWithIndex.map(pair => pair._1 + " has index " + pair._2) + List("a", "b", "c").toObservable.zipWithIndex.map(pair => pair._1 + " has index " + pair._2) .toBlockingObservable.foreach(println(_)) // Or even nicer with for-comprehension syntax: - (for ((letter, index) <- Observable("a", "b", "c").zipWithIndex) yield letter + " has index " + index) + (for ((letter, index) <- List("a", "b", "c").toObservable.zipWithIndex) yield letter + " has index " + index) .toBlockingObservable.foreach(println(_)) } // source Observables are all known: @Test def zip3Example() { - val o = Observable.zip(Observable(1, 2), Observable(10, 20), Observable(100, 200)) + val o = Observable.zip(List(1, 2).toObservable, List(10, 20).toObservable, List(100, 200).toObservable) (for ((n1, n2, n3) <- o) yield s"$n1, $n2 and $n3") .toBlockingObservable.foreach(println(_)) } // source Observables are in an Observable: @Test def zipManyObservableExample() { - val observables = Observable(Observable(1, 2), Observable(10, 20), Observable(100, 200)) + val observables = List(List(1, 2).toObservable, List(10, 20).toObservable, List(100, 200).toObservable).toObservable (for (seq <- Observable.zip(observables)) yield seq.mkString("(", ", ", ")")) .toBlockingObservable.foreach(println(_)) } @Test def takeFirstWithCondition() { val condition: Int => Boolean = _ >= 3 - assertEquals(3, Observable(1, 2, 3, 4).filter(condition).first.toBlockingObservable.single) + assertEquals(3, List(1, 2, 3, 4).toObservable.filter(condition).first.toBlockingObservable.single) } @Test def firstOrDefaultWithCondition() { val condition: Int => Boolean = _ >= 3 - assertEquals(3, Observable(1, 2, 3, 4).filter(condition).firstOrElse(10).toBlockingObservable.single) - assertEquals(10, Observable(-1, 0, 1).filter(condition).firstOrElse(10).toBlockingObservable.single) + assertEquals(3, List(1, 2, 3, 4).toObservable.filter(condition).firstOrElse(10).toBlockingObservable.single) + assertEquals(10, List(-1, 0, 1).toObservable.filter(condition).firstOrElse(10).toBlockingObservable.single) } def square(x: Int): Int = { @@ -379,9 +379,9 @@ class RxScalaDemo extends JUnitSuite { } @Test def toSortedList() { - assertEquals(Seq(7, 8, 9, 10), Observable(10, 7, 8, 9).toSeq.map(_.sorted).toBlockingObservable.single) + assertEquals(Seq(7, 8, 9, 10), List(10, 7, 8, 9).toObservable.toSeq.map(_.sorted).toBlockingObservable.single) val f = (a: Int, b: Int) => b < a - assertEquals(Seq(10, 9, 8, 7), Observable(10, 7, 8, 9).toSeq.map(_.sortWith(f)).toBlockingObservable.single) + assertEquals(Seq(10, 9, 8, 7), List(10, 7, 8, 9).toObservable.toSeq.map(_.sortWith(f)).toBlockingObservable.single) } @Test def timestampExample() { @@ -410,7 +410,7 @@ class RxScalaDemo extends JUnitSuite { @Test def materializeExample2() { import Notification._ - Observable(1, 2, 3).materialize.subscribe(n => n match { + List(1, 2, 3).toObservable.materialize.subscribe(n => n match { case OnNext(v) => println("Got value " + v) case OnCompleted() => println("Completed") case OnError(err) => println("Error: " + err.getMessage) @@ -418,17 +418,17 @@ class RxScalaDemo extends JUnitSuite { } @Test def elementAtReplacement() { - assertEquals("b", Observable("a", "b", "c").drop(1).first.toBlockingObservable.single) + assertEquals("b", List("a", "b", "c").toObservable.drop(1).first.toBlockingObservable.single) } @Test def elementAtOrDefaultReplacement() { - assertEquals("b", Observable("a", "b", "c").drop(1).firstOrElse("!").toBlockingObservable.single) - assertEquals("!!", Observable("a", "b", "c").drop(10).firstOrElse("!!").toBlockingObservable.single) + assertEquals("b", List("a", "b", "c").toObservable.drop(1).firstOrElse("!").toBlockingObservable.single) + assertEquals("!!", List("a", "b", "c").toObservable.drop(10).firstOrElse("!!").toBlockingObservable.single) } @Test def takeWhileWithIndexAlternative { val condition = true - Observable("a", "b").zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1) + List("a", "b").toObservable.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1) } @Test def createExample() { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala index d777a91700..6db7d41e25 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala @@ -120,7 +120,6 @@ trait Observable[+T] * @return $subscribeAllReturn */ def apply(observer: Observer[T]): Subscription = subscribe(observer) - def apply(): Subscription = subscribe() /** * $subscribeCallbacksMainNoNotifications @@ -544,7 +543,7 @@ trait Observable[+T] def window[Closing](closings: () => Observable[Closing]): Observable[Observable[T]] = { val func : Func0[_ <: rx.Observable[_ <: Closing]] = closings().asJavaObservable val o1: rx.Observable[_ <: rx.Observable[_]] = asJavaObservable.window[Closing](func) - val o2 = Observable[rx.Observable[_]](o1).map((x: rx.Observable[_]) => { + val o2 = Observable.items(o1).map((x: rx.Observable[_]) => { val x2 = x.asInstanceOf[rx.Observable[_ <: T]] toScalaObservable[T](x2) }) @@ -1985,6 +1984,48 @@ object Observable { toScalaObservable[T](rx.Observable.error(exception)) } + /** + * Returns an Observable that emits no data to the [[rx.lang.scala.Observer]] and + * immediately invokes its [[rx.lang.scala.Observer#onCompleted onCompleted]] method + * with the specified scheduler. + *

+ * + * + * @param scheduler the scheduler to call the + [[rx.lang.scala.Observer#onCompleted onCompleted]] method + * @param T the type of the items (ostensibly) emitted by the Observable + * @return an Observable that returns no data to the [[rx.lang.scala.Observer]] and + * immediately invokes the [[rx.lang.scala.Observer]]r's + * [[rx.lang.scala.Observer#onCompleted onCompleted]] method with the + * specified scheduler + * @see RxJava Wiki: empty() + * @see MSDN: Observable.Empty Method (IScheduler) + */ + def empty[T]: Observable[T] = { + toScalaObservable(rx.Observable.empty[T]()) + } + + /** + * Returns an Observable that emits no data to the [[rx.lang.scala.Observer]] and + * immediately invokes its [[rx.lang.scala.Observer#onCompleted onCompleted]] method + * with the specified scheduler. + *

+ * + * + * @param scheduler the scheduler to call the + [[rx.lang.scala.Observer#onCompleted onCompleted]] method + * @param T the type of the items (ostensibly) emitted by the Observable + * @return an Observable that returns no data to the [[rx.lang.scala.Observer]] and + * immediately invokes the [[rx.lang.scala.Observer]]r's + * [[rx.lang.scala.Observer#onCompleted onCompleted]] method with the + * specified scheduler + * @see RxJava Wiki: empty() + * @see MSDN: Observable.Empty Method (IScheduler) + */ + def empty[T](scheduler: Scheduler): Observable[T] = { + toScalaObservable(rx.Observable.empty[T](scalaSchedulerToJavaScheduler(scheduler))) + } + /** * Converts a sequence of values into an Observable. * @@ -2001,10 +2042,6 @@ object Observable { * resulting Observable * @return an Observable that emits each item in the source Array */ - def apply[T](items: T*): Observable[T] = { - toScalaObservable[T](rx.Observable.from(items.toIterable.asJava)) - } - def items[T](items: T*): Observable[T] = { toScalaObservable[T](rx.Observable.from(items.toIterable.asJava)) } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala index 55a79b8af6..aa6cd4339e 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/package.scala @@ -26,7 +26,7 @@ package object scala { * Placeholder for extension methods into Observable[T] from other types */ implicit class ObservableExtensions[T](val source: Iterable[T]) extends AnyVal { - def toObservable(): Observable[T] = { Observable.from(source) } + def toObservable: Observable[T] = { Observable.from(source) } def toObservable(scheduler: Scheduler): Observable[T] = { Observable.from(source, scheduler) } } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala index 2249a47729..e2822405b2 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala @@ -7,13 +7,13 @@ import org.scalatest.junit.JUnitSuite class ConstructorTest extends JUnitSuite { @Test def toObservable() { - val xs = List(1,2,3).toObservable().toBlockingObservable.toList + val xs = List(1,2,3).toObservable.toBlockingObservable.toList assertEquals(List(1,2,3), xs) - val ys = Observable(List(1,2,3)).toBlockingObservable.toList + val ys = Observable.from(List(1,2,3)).toBlockingObservable.toList assertEquals(List(1,2,3), xs) - val zs = Observable(1,2,3).toBlockingObservable.toList + val zs = Observable.items(1,2,3).toBlockingObservable.toList assertEquals(List(1,2,3), xs) } diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index 6540a6afcd..0b755833da 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -21,7 +21,7 @@ class ObservableTests extends JUnitSuite { def testCovariance = { //println("hey, you shouldn't run this test") - val o1: Observable[Nothing] = Observable() + val o1: Observable[Nothing] = Observable.empty val o2: Observable[Int] = o1 val o3: Observable[App] = o1 val o4: Observable[Any] = o2 @@ -32,7 +32,7 @@ class ObservableTests extends JUnitSuite { @Test def testDematerialize() { - val o = Observable(1, 2, 3) + val o = List(1, 2, 3).toObservable val mat = o.materialize val demat = mat.dematerialize @@ -61,8 +61,8 @@ class ObservableTests extends JUnitSuite { @Test def testFirstOrElse() { def mustNotBeCalled: String = sys.error("this method should not be called") def mustBeCalled: String = "this is the default value" - assertEquals("hello", Observable("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) - assertEquals("this is the default value", Observable().firstOrElse(mustBeCalled).toBlockingObservable.single) + assertEquals("hello", Observable.items("hello").firstOrElse(mustNotBeCalled).toBlockingObservable.single) + assertEquals("this is the default value", Observable.empty.firstOrElse(mustBeCalled).toBlockingObservable.single) } @Test def testTestWithError() { From 79ef52fc5daf588bf1a25e068cd3c98abf5c13fa Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 20:30:15 -0800 Subject: [PATCH 067/441] Release notes edits. --- language-adaptors/rxjava-scala/ReleaseNotes.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 659022da8e..52ec13afc9 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -2,16 +2,18 @@ RxScala Release Notes ===================== This release of the RxScala bindings builds on the previous 0.15 release to make the Rx bindings for Scala -include all Rx types. In particular this release focuses on fleshing out the bindings for the `Subject` and `Scheduler` types. -To makes these notes self-contained, we will start with the `Observer[T]` and `Observable[T]` traits -that lay at the heart of Rx. +include all Rx types. In particular this release focuses on fleshing out the bindings for the `Subject` and `Scheduler` +types, as well as aligning the constructor functions for `Observable` with those in the RxJava. + +Expect to see ongoing additions to make the Scala binding match the equivalent underlying Java API, +as well as minor changes in the existing API as we keep fine-tuning the experience on our way to a V1.0 release. Observer -------- In this release we have made the `asJavaObserver` property in `Observable[T]`as well the the factory method in the - companion object that takes an `rx.Observer` private to the Scala bindings package, thus properly hiding irrelevant - implementation details from the user-facing API. The `Observer[T]` trait now looks like a clean, native Scala type: +companion object that takes an `rx.Observer` private to the Scala bindings package, thus properly hiding irrelevant +implementation details from the user-facing API. The `Observer[T]` trait now looks like a clean, native Scala type: ```scala trait Observer[-T] { From 9af8568c20cd0002234fef546f072f66ef8c6631 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Mon, 9 Dec 2013 20:34:11 -0800 Subject: [PATCH 068/441] Release notes edits. --- .../rxjava-scala/ReleaseNotes.md | 43 ++++++++++--------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/language-adaptors/rxjava-scala/ReleaseNotes.md b/language-adaptors/rxjava-scala/ReleaseNotes.md index 52ec13afc9..4fdb3a06fd 100644 --- a/language-adaptors/rxjava-scala/ReleaseNotes.md +++ b/language-adaptors/rxjava-scala/ReleaseNotes.md @@ -67,11 +67,12 @@ method hindered type inference and made Scala code look unnecessarily different All factory methods now have their own name corresponding to the Java and .NET operators (plus overloads that take a `Scheduler`). -* `def from[T](future: Future[T]): Observable[T]` -* `def from[T](iterable: Iterable[T]): Observable[T]` -* `def error[T](exception: Throwable): Observable[T]` -* `def empty[T]: Observable[T]` -* `def items[T](items: T*): Observable[T] +* `def from[T](future: Future[T]): Observable[T]`, +* `def from[T](iterable: Iterable[T]): Observable[T]`, +* `def error[T](exception: Throwable): Observable[T]`, +* `def empty[T]: Observable[T]`, +* `def items[T](items: T*): Observable[T], +* Extension method on `toObservable: Observable[T]` on `List[T]`. In the *pre-release* of this version, we expose both `apply` and `create` for the mother of all creation functions. We would like to solicit feedback which of these two names is preferred @@ -96,10 +97,10 @@ object Subject { For each kind of subject, there is a class with a private constructor and a companion object that you should use to create a new kind of subject. The subjects that are available are: -* `AsyncSubject[T]()` -* `BehaviorSubject[T](value)` -* `Subject[T]()` -* `ReplaySubject[T]()` +* `AsyncSubject[T]()`, +* `BehaviorSubject[T](value)`, +* `Subject[T]()`, +* `ReplaySubject[T]()`. The latter is still missing various overloads http://msdn.microsoft.com/en-us/library/hh211810(v=vs.103).aspx which you can expect to appear once they are added to the underlying RxJava implementation. @@ -128,14 +129,14 @@ which already deviated from the pattern. In this release, we changed this to make scheduler more like `Subject` and provide a family of schedulers that you create using their factory function: -* `CurrentThreadScheduler()` -* `ExecutorScheduler(executor)` -* `ImmediateScheduler()` -* `NewThreadScheduler()` -* `ScheduledExecutorServiceScheduler(scheduledExecutorService)` -* `TestScheduler()` -* `ThreadPoolForComputationScheduler()` -* `ThreadPoolForIOScheduler()` +* `CurrentThreadScheduler()`, +* `ExecutorScheduler(executor)`, +* `ImmediateScheduler()`, +* `NewThreadScheduler()`, +* `ScheduledExecutorServiceScheduler(scheduledExecutorService)`, +* `TestScheduler()`, +* `ThreadPoolForComputationScheduler()`, +* `ThreadPoolForIOScheduler()`. In the future we expect that this list will grow further with new schedulers as they are imported from .NET (http://msdn.microsoft.com/en-us/library/system.reactive.concurrency(v=vs.103).aspx). @@ -162,10 +163,10 @@ object Subscription {...} To create a `Subscription` use one of the following factory methods: - * `Subscription{...}`, `Subscription()` - * `CompositeSubscription(subscriptions)` - * `MultipleAssignmentSubscription()` - * `SerialSubscription()` + * `Subscription{...}`, `Subscription()`, + * `CompositeSubscription(subscriptions)`, + * `MultipleAssignmentSubscription()`, + * `SerialSubscription()`. In case you do feel tempted to call `new Subscription{...}` directly make sure you wire up `isUnsubscribed` and `unsubscribe()` properly, but for all practical purposes you should just use one of the factory methods. From 46544c38c74e9df451a880ceaf460ad786d2c26e Mon Sep 17 00:00:00 2001 From: zsxwing Date: Tue, 10 Dec 2013 22:45:02 +0800 Subject: [PATCH 069/441] Add more unit tests --- .../src/test/java/rx/ObservableTests.java | 213 ++++++++++++++++-- 1 file changed, 188 insertions(+), 25 deletions(-) diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index 50661238b6..6e703a57ce 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -953,15 +953,8 @@ public void testRangeWithScheduler() { @Test public void testStartWithAction() { - TestScheduler scheduler = new TestScheduler(); - Action0 action = mock(Action0.class); - Observable observable = Observable.start(action, scheduler); - scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); - - assertEquals(null, observable.toBlockingObservable().single()); - assertEquals(null, observable.toBlockingObservable().single()); - verify(action, times(1)).call(); + assertEquals(null, Observable.start(action).toBlockingObservable().single()); } @Test(expected = RuntimeException.class) @@ -972,44 +965,214 @@ public void call() { throw new RuntimeException("Some error"); } }; + Observable.start(action).toBlockingObservable().single(); + } + + @Test + public void testStartWhenSubscribeRunBeforeAction() { + TestScheduler scheduler = new TestScheduler(); + + Action0 action = mock(Action0.class); + + Observable observable = Observable.start(action, scheduler); + + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verifyNoMoreInteractions(); + + // Run action + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); - Observable observable = Observable.start(action); - observable.toBlockingObservable().single(); + inOrder.verify(observer, times(1)).onNext(null); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); } @Test - public void testStartWithFunc() { + public void testStartWhenSubscribeRunAfterAction() { TestScheduler scheduler = new TestScheduler(); + Action0 action = mock(Action0.class); + + Observable observable = Observable.start(action, scheduler); + + // Run action + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + @SuppressWarnings("unchecked") - Func0 func = (Func0) mock(Func0.class); - doAnswer(new Answer() { + Observer observer = mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(null); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testStartWithActionAndMultipleObservers() { + TestScheduler scheduler = new TestScheduler(); + Action0 action = mock(Action0.class); + + Observable observable = Observable.start(action, scheduler); + + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + @SuppressWarnings("unchecked") + Observer observer1 = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observer2 = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observer3 = mock(Observer.class); + + observable.subscribe(observer1); + observable.subscribe(observer2); + observable.subscribe(observer3); + + InOrder inOrder; + inOrder = inOrder(observer1); + inOrder.verify(observer1, times(1)).onNext(null); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + inOrder = inOrder(observer2); + inOrder.verify(observer2, times(1)).onNext(null); + inOrder.verify(observer2, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + inOrder = inOrder(observer3); + inOrder.verify(observer3, times(1)).onNext(null); + inOrder.verify(observer3, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + verify(action, times(1)).call(); + } + + @Test + public void testStartWithFunc() { + Func0 func = new Func0() { @Override - public String answer(InvocationOnMock invocation) throws Throwable { + public String call() { return "one"; } + }; + assertEquals("one", Observable.start(func).toBlockingObservable().single()); + } - }).when(func).call(); + @Test(expected = RuntimeException.class) + public void testStartWithFuncError() { + Func0 func = new Func0() { + @Override + public String call() { + throw new RuntimeException("Some error"); + } + }; + Observable.start(func).toBlockingObservable().single(); + } + + @Test + public void testStartWhenSubscribeRunBeforeFunc() { + TestScheduler scheduler = new TestScheduler(); + + Func0 func = new Func0() { + @Override + public String call() { + return "one"; + } + }; Observable observable = Observable.start(func, scheduler); - scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); - assertEquals("one", observable.toBlockingObservable().single()); - assertEquals("one", observable.toBlockingObservable().single()); - verify(func, times(1)).call(); + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verifyNoMoreInteractions(); + + // Run func + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + inOrder.verify(observer, times(1)).onNext("one"); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); } - @Test(expected = RuntimeException.class) - public void testStartWithFuncError() { + @Test + public void testStartWhenSubscribeRunAfterFunc() { + TestScheduler scheduler = new TestScheduler(); + Func0 func = new Func0() { @Override public String call() { - throw new RuntimeException("Some error"); + return "one"; } }; - Observable observable = Observable.start(func); - observable.toBlockingObservable().single(); + Observable observable = Observable.start(func, scheduler); + + // Run func + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + @SuppressWarnings("unchecked") + Observer observer = mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext("one"); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); } -} \ No newline at end of file + + @Test + public void testStartWithFuncAndMultipleObservers() { + TestScheduler scheduler = new TestScheduler(); + + @SuppressWarnings("unchecked") + Func0 func = (Func0) mock(Func0.class); + doAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + return "one"; + } + }).when(func).call(); + + Observable observable = Observable.start(func, scheduler); + + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + @SuppressWarnings("unchecked") + Observer observer1 = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observer2 = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observer3 = mock(Observer.class); + + observable.subscribe(observer1); + observable.subscribe(observer2); + observable.subscribe(observer3); + + InOrder inOrder; + inOrder = inOrder(observer1); + inOrder.verify(observer1, times(1)).onNext("one"); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + inOrder = inOrder(observer2); + inOrder.verify(observer2, times(1)).onNext("one"); + inOrder.verify(observer2, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + inOrder = inOrder(observer3); + inOrder.verify(observer3, times(1)).onNext("one"); + inOrder.verify(observer3, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + + verify(func, times(1)).call(); + } + +} From d42b6453a35e6aba72d467e88997a0adcb57b916 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:12:59 -0800 Subject: [PATCH 070/441] Migrate Schedulers to rx.schedulers package --- .../rx/{concurrency => schedulers}/CurrentThreadScheduler.java | 2 +- .../java/rx/schedulers}/CurrentThreadSchedulerTest.java | 2 +- .../java/rx/{concurrency => schedulers}/DiscardableAction.java | 2 +- .../java/rx/{concurrency => schedulers}/ExecutorScheduler.java | 2 +- .../GenericScheduledExecutorService.java | 2 +- .../java/rx/{concurrency => schedulers}/ImmediateScheduler.java | 2 +- .../java/rx/schedulers}/ImmediateSchedulerTest.java | 2 +- .../java/rx/{concurrency => schedulers}/NewThreadScheduler.java | 2 +- .../main/java/rx/{concurrency => schedulers}/Schedulers.java | 2 +- .../java/rx/{concurrency => schedulers}/SleepingAction.java | 2 +- .../main/java/rx/{concurrency => schedulers}/TestScheduler.java | 2 +- .../main/java/rx/{concurrency => schedulers}/package-info.java | 2 +- 12 files changed, 12 insertions(+), 12 deletions(-) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/CurrentThreadScheduler.java (99%) rename rxjava-core/src/{test/java/rx/concurrency => main/java/rx/schedulers}/CurrentThreadSchedulerTest.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/DiscardableAction.java (98%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/ExecutorScheduler.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/GenericScheduledExecutorService.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/ImmediateScheduler.java (98%) rename rxjava-core/src/{test/java/rx/concurrency => main/java/rx/schedulers}/ImmediateSchedulerTest.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/NewThreadScheduler.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/Schedulers.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/SleepingAction.java (98%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/TestScheduler.java (99%) rename rxjava-core/src/main/java/rx/{concurrency => schedulers}/package-info.java (96%) diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java rename to rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java index 9bf1f6ad91..d1550a2422 100644 --- a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.PriorityQueue; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/test/java/rx/concurrency/CurrentThreadSchedulerTest.java b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadSchedulerTest.java similarity index 99% rename from rxjava-core/src/test/java/rx/concurrency/CurrentThreadSchedulerTest.java rename to rxjava-core/src/main/java/rx/schedulers/CurrentThreadSchedulerTest.java index 3613b7c592..b71d96af9e 100644 --- a/rxjava-core/src/test/java/rx/concurrency/CurrentThreadSchedulerTest.java +++ b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadSchedulerTest.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import static org.mockito.Mockito.*; diff --git a/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java b/rxjava-core/src/main/java/rx/schedulers/DiscardableAction.java similarity index 98% rename from rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java rename to rxjava-core/src/main/java/rx/schedulers/DiscardableAction.java index 94d04075c5..4ba336a864 100644 --- a/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java +++ b/rxjava-core/src/main/java/rx/schedulers/DiscardableAction.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.atomic.AtomicBoolean; diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java rename to rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java index 1e35735c67..563e609612 100644 --- a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; diff --git a/rxjava-core/src/main/java/rx/concurrency/GenericScheduledExecutorService.java b/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/GenericScheduledExecutorService.java rename to rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java index 8bb520d9fe..14546301c5 100644 --- a/rxjava-core/src/main/java/rx/concurrency/GenericScheduledExecutorService.java +++ b/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java similarity index 98% rename from rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java rename to rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java index c5a4cef9d4..3963bce4c5 100644 --- a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/test/java/rx/concurrency/ImmediateSchedulerTest.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateSchedulerTest.java similarity index 99% rename from rxjava-core/src/test/java/rx/concurrency/ImmediateSchedulerTest.java rename to rxjava-core/src/main/java/rx/schedulers/ImmediateSchedulerTest.java index 593f6b6a52..bfece3af6c 100644 --- a/rxjava-core/src/test/java/rx/concurrency/ImmediateSchedulerTest.java +++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateSchedulerTest.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import static org.mockito.Mockito.*; diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java rename to rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java index 036ba62127..b2fdff50d2 100644 --- a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; diff --git a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/Schedulers.java rename to rxjava-core/src/main/java/rx/schedulers/Schedulers.java index 1b27b9bf0a..b0c6a0cc9b 100644 --- a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java +++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.concurrent.Executor; import java.util.concurrent.Executors; diff --git a/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java similarity index 98% rename from rxjava-core/src/main/java/rx/concurrency/SleepingAction.java rename to rxjava-core/src/main/java/rx/schedulers/SleepingAction.java index 925403e846..33b1e869df 100644 --- a/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java +++ b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import rx.Scheduler; import rx.Subscription; diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java similarity index 99% rename from rxjava-core/src/main/java/rx/concurrency/TestScheduler.java rename to rxjava-core/src/main/java/rx/schedulers/TestScheduler.java index 04b8c1a2c5..27c8e44f9b 100644 --- a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package rx.concurrency; +package rx.schedulers; import java.util.Comparator; import java.util.PriorityQueue; diff --git a/rxjava-core/src/main/java/rx/concurrency/package-info.java b/rxjava-core/src/main/java/rx/schedulers/package-info.java similarity index 96% rename from rxjava-core/src/main/java/rx/concurrency/package-info.java rename to rxjava-core/src/main/java/rx/schedulers/package-info.java index e0657722fb..0bfe32d474 100644 --- a/rxjava-core/src/main/java/rx/concurrency/package-info.java +++ b/rxjava-core/src/main/java/rx/schedulers/package-info.java @@ -16,4 +16,4 @@ /** * Rx Schedulers */ -package rx.concurrency; \ No newline at end of file +package rx.schedulers; \ No newline at end of file From 019aa93a39db36019033d18f23a78b331f5cd445 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:14:42 -0800 Subject: [PATCH 071/441] Organize Imports - Migrate to rx.schedulers for src/main --- rxjava-core/src/main/java/rx/Observable.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationBuffer.java | 2 +- .../src/main/java/rx/operators/OperationDebounce.java | 2 +- .../src/main/java/rx/operators/OperationDoOnEach.java | 2 +- .../src/main/java/rx/operators/OperationGroupByUntil.java | 1 + .../src/main/java/rx/operators/OperationGroupJoin.java | 1 + .../src/main/java/rx/operators/OperationInterval.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationJoin.java | 1 + .../src/main/java/rx/operators/OperationJoinPatterns.java | 3 +-- .../src/main/java/rx/operators/OperationObserveOn.java | 5 ++--- .../src/main/java/rx/operators/OperationParallel.java | 2 +- .../src/main/java/rx/operators/OperationParallelMerge.java | 2 +- .../main/java/rx/operators/OperationParallelMergeTest.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationRetry.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationSample.java | 3 +-- .../src/main/java/rx/operators/OperationSequenceEqual.java | 4 +--- .../src/main/java/rx/operators/OperationSkipUntil.java | 1 + .../src/main/java/rx/operators/OperationThrottleFirst.java | 2 +- .../src/main/java/rx/operators/OperationTimeInterval.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationTimeout.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationTimer.java | 2 +- rxjava-core/src/main/java/rx/operators/OperationToMap.java | 1 + .../src/main/java/rx/operators/OperationToMultimap.java | 1 + rxjava-core/src/main/java/rx/operators/OperationWindow.java | 2 +- rxjava-core/src/main/java/rx/util/functions/Actions.java | 2 -- rxjava-core/src/main/java/rx/util/functions/Async.java | 4 ++-- 26 files changed, 27 insertions(+), 28 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 15a4d5bff6..e11f9b7056 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -27,7 +27,6 @@ import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; -import rx.concurrency.Schedulers; import rx.joins.Pattern2; import rx.joins.Plan0; import rx.observables.BlockingObservable; @@ -109,6 +108,7 @@ import rx.plugins.RxJavaErrorHandler; import rx.plugins.RxJavaObservableExecutionHook; import rx.plugins.RxJavaPlugins; +import rx.schedulers.Schedulers; import rx.subjects.AsyncSubject; import rx.subjects.PublishSubject; import rx.subjects.ReplaySubject; diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java index 72cc1df211..d7c63df23e 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java +++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java @@ -24,7 +24,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.CompositeSubscription; import rx.util.functions.Func0; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java index 3dbdd81f20..2e312fee31 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java +++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java @@ -23,7 +23,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Action0; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java index 1b0aafb578..871238a0b0 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java +++ b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java @@ -16,8 +16,8 @@ package rx.operators; import rx.Observable; -import rx.Observer; import rx.Observable.OnSubscribeFunc; +import rx.Observer; import rx.Subscription; /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java index 9869862b92..63a271a688 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java +++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java @@ -19,6 +19,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java index 9c14efd632..56d009db0a 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java +++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java @@ -19,6 +19,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java index 72d35d37de..e6711bfb9e 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java +++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java @@ -21,7 +21,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java index b75b8498b0..f75bf10930 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java +++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java @@ -17,6 +17,7 @@ import java.util.HashMap; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java index ffc304e12a..be3c5375cf 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java +++ b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java @@ -20,6 +20,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; @@ -29,11 +30,9 @@ import rx.joins.Pattern1; import rx.joins.Pattern2; import rx.joins.Plan0; -import rx.subjects.PublishSubject; import rx.subscriptions.CompositeSubscription; import rx.util.functions.Action1; import rx.util.functions.Func1; -import rx.util.functions.Func2; /** * Join patterns: And, Then, When. diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java index 22876a4ced..fed1cf4bb0 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java +++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java @@ -24,10 +24,9 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.CurrentThreadScheduler; -import rx.concurrency.ImmediateScheduler; +import rx.schedulers.CurrentThreadScheduler; +import rx.schedulers.ImmediateScheduler; import rx.subscriptions.CompositeSubscription; -import rx.subscriptions.SerialSubscription; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; import rx.util.functions.Action1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallel.java b/rxjava-core/src/main/java/rx/operators/OperationParallel.java index 5a584ce370..32ad3181f3 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationParallel.java +++ b/rxjava-core/src/main/java/rx/operators/OperationParallel.java @@ -19,8 +19,8 @@ import rx.Observable; import rx.Scheduler; -import rx.concurrency.Schedulers; import rx.observables.GroupedObservable; +import rx.schedulers.Schedulers; import rx.util.functions.Func0; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java index cb2dd0bc34..86aa31c609 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java +++ b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java @@ -19,8 +19,8 @@ import rx.Observable; import rx.Scheduler; -import rx.concurrency.Schedulers; import rx.observables.GroupedObservable; +import rx.schedulers.Schedulers; import rx.util.functions.Func1; public class OperationParallelMerge { diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java index a001877a71..907993ef10 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java +++ b/rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java @@ -24,7 +24,7 @@ import org.junit.Test; import rx.Observable; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subjects.PublishSubject; import rx.util.functions.Action1; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationRetry.java b/rxjava-core/src/main/java/rx/operators/OperationRetry.java index 430ef53ce4..450dfe3ebb 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationRetry.java +++ b/rxjava-core/src/main/java/rx/operators/OperationRetry.java @@ -23,7 +23,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.CompositeSubscription; import rx.subscriptions.MultipleAssignmentSubscription; import rx.util.functions.Func2; diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java index f5f8f96e3f..a7fb426bf1 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationSample.java +++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java @@ -24,9 +24,8 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.CompositeSubscription; -import rx.subscriptions.SerialSubscription; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java index 423ddbc358..16300b664e 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java +++ b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java @@ -15,9 +15,7 @@ */ package rx.operators; -import static rx.Observable.concat; -import static rx.Observable.from; -import static rx.Observable.zip; +import static rx.Observable.*; import rx.Notification; import rx.Observable; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java index e8f04fd383..7e89b741e8 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java +++ b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java @@ -16,6 +16,7 @@ package rx.operators; import java.util.concurrent.atomic.AtomicBoolean; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java index e21617a82c..8f5568d1b5 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java +++ b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java @@ -23,7 +23,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Func1; /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java index 2cd1860711..fe45b0c72d 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java +++ b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java @@ -20,7 +20,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.TimeInterval; /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java index b52c7a5a43..8f4c5b4b0e 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java +++ b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java @@ -25,7 +25,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.CompositeSubscription; import rx.subscriptions.SerialSubscription; import rx.util.functions.Action0; diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java index 3bb462cac0..c8f9f3b33c 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java +++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java @@ -21,7 +21,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java index 754ff82d64..12963ce6a4 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java +++ b/rxjava-core/src/main/java/rx/operators/OperationToMap.java @@ -18,6 +18,7 @@ import java.util.HashMap; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java index 7210ee45e7..92e8f68432 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java +++ b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java @@ -20,6 +20,7 @@ import java.util.Collection; import java.util.HashMap; import java.util.Map; + import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java index f18a700bd2..ef867898ed 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java +++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java @@ -22,7 +22,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Func0; import rx.util.functions.Func1; diff --git a/rxjava-core/src/main/java/rx/util/functions/Actions.java b/rxjava-core/src/main/java/rx/util/functions/Actions.java index 4fb017cb36..7a33d451ce 100644 --- a/rxjava-core/src/main/java/rx/util/functions/Actions.java +++ b/rxjava-core/src/main/java/rx/util/functions/Actions.java @@ -16,8 +16,6 @@ package rx.util.functions; import rx.Observer; -import rx.util.functions.Action0; -import rx.util.functions.Action1; /** * Utility class for the Action interfaces. diff --git a/rxjava-core/src/main/java/rx/util/functions/Async.java b/rxjava-core/src/main/java/rx/util/functions/Async.java index f31ab3780c..51a1787715 100644 --- a/rxjava-core/src/main/java/rx/util/functions/Async.java +++ b/rxjava-core/src/main/java/rx/util/functions/Async.java @@ -18,8 +18,8 @@ import rx.Observable; import rx.Scheduler; -import rx.concurrency.ExecutorScheduler; -import rx.concurrency.Schedulers; +import rx.schedulers.ExecutorScheduler; +import rx.schedulers.Schedulers; import rx.subjects.AsyncSubject; /** From abff40fd0a40bee4f97b0363014e98aecb50d7ff Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:35:01 -0800 Subject: [PATCH 072/441] Backwards compatible deprecated rx.concurrency classes These will exist for a few releases to allow people to migrate from rx.concurrency to rx.schedulers. --- .../concurrency/CurrentThreadScheduler.java | 39 +++++++ .../rx/concurrency/ExecutorScheduler.java | 24 +++++ .../rx/concurrency/ImmediateScheduler.java | 39 +++++++ .../rx/concurrency/NewThreadScheduler.java | 39 +++++++ .../src/main/java/rx/concurrency/README.txt | 3 + .../main/java/rx/concurrency/Schedulers.java | 100 ++++++++++++++++++ .../java/rx/concurrency/TestScheduler.java | 14 +++ .../operators/OperationParallelMergeTest.java | 0 .../CurrentThreadSchedulerTest.java | 0 .../rx/schedulers/ImmediateSchedulerTest.java | 0 10 files changed, 258 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java create mode 100644 rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java create mode 100644 rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java create mode 100644 rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java create mode 100644 rxjava-core/src/main/java/rx/concurrency/README.txt create mode 100644 rxjava-core/src/main/java/rx/concurrency/Schedulers.java create mode 100644 rxjava-core/src/main/java/rx/concurrency/TestScheduler.java rename rxjava-core/src/{main => test}/java/rx/operators/OperationParallelMergeTest.java (100%) rename rxjava-core/src/{main => test}/java/rx/schedulers/CurrentThreadSchedulerTest.java (100%) rename rxjava-core/src/{main => test}/java/rx/schedulers/ImmediateSchedulerTest.java (100%) diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java new file mode 100644 index 0000000000..ed905af3e5 --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java @@ -0,0 +1,39 @@ +package rx.concurrency; + +import java.util.concurrent.TimeUnit; + +import rx.Scheduler; +import rx.Subscription; +import rx.util.functions.Func2; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.CurrentThreadScheduler} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class CurrentThreadScheduler extends Scheduler { + + private final static CurrentThreadScheduler INSTANCE = new CurrentThreadScheduler(); + + public static CurrentThreadScheduler getInstance() { + return INSTANCE; + } + + private final rx.schedulers.CurrentThreadScheduler actual; + + private CurrentThreadScheduler() { + actual = rx.schedulers.CurrentThreadScheduler.getInstance(); + } + + @Override + public Subscription schedule(T state, Func2 action) { + return actual.schedule(state, action); + } + + @Override + public Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) { + return actual.schedule(state, action, delayTime, unit); + } + +} diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java new file mode 100644 index 0000000000..ecfcddc286 --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java @@ -0,0 +1,24 @@ +package rx.concurrency; + +import java.util.concurrent.Executor; +import java.util.concurrent.ScheduledExecutorService; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.ExecutorScheduler} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class ExecutorScheduler extends rx.schedulers.ExecutorScheduler { + + @Deprecated + public ExecutorScheduler(Executor executor) { + super(executor); + } + + @Deprecated + public ExecutorScheduler(ScheduledExecutorService executor) { + super(executor); + } + +} diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java new file mode 100644 index 0000000000..001208d64c --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java @@ -0,0 +1,39 @@ +package rx.concurrency; + +import java.util.concurrent.TimeUnit; + +import rx.Scheduler; +import rx.Subscription; +import rx.util.functions.Func2; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.ImmediateScheduler} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class ImmediateScheduler extends Scheduler { + + private final static ImmediateScheduler INSTANCE = new ImmediateScheduler(); + + public static ImmediateScheduler getInstance() { + return INSTANCE; + } + + private final rx.schedulers.ImmediateScheduler actual; + + private ImmediateScheduler() { + actual = rx.schedulers.ImmediateScheduler.getInstance(); + } + + @Override + public Subscription schedule(T state, Func2 action) { + return actual.schedule(state, action); + } + + @Override + public Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) { + return actual.schedule(state, action, delayTime, unit); + } + +} diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java new file mode 100644 index 0000000000..fac4aa1fe0 --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java @@ -0,0 +1,39 @@ +package rx.concurrency; + +import java.util.concurrent.TimeUnit; + +import rx.Scheduler; +import rx.Subscription; +import rx.util.functions.Func2; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.NewThreadScheduler} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class NewThreadScheduler extends Scheduler { + + private final static NewThreadScheduler INSTANCE = new NewThreadScheduler(); + + public static NewThreadScheduler getInstance() { + return INSTANCE; + } + + private final rx.schedulers.NewThreadScheduler actual; + + private NewThreadScheduler() { + actual = rx.schedulers.NewThreadScheduler.getInstance(); + } + + @Override + public Subscription schedule(T state, Func2 action) { + return actual.schedule(state, action); + } + + @Override + public Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) { + return actual.schedule(state, action, delayTime, unit); + } + +} diff --git a/rxjava-core/src/main/java/rx/concurrency/README.txt b/rxjava-core/src/main/java/rx/concurrency/README.txt new file mode 100644 index 0000000000..d9048bbbc9 --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/README.txt @@ -0,0 +1,3 @@ +This package is deprecated and will be removed prior to a 1.0 release. + +Use rx.schedulers.* instead of rx.concurrency.* \ No newline at end of file diff --git a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java new file mode 100644 index 0000000000..a257d54e67 --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java @@ -0,0 +1,100 @@ +package rx.concurrency; + +import java.util.concurrent.Executor; +import java.util.concurrent.ScheduledExecutorService; + +import rx.Scheduler; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.Schedulers} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class Schedulers { + + /** + * {@link Scheduler} that executes work immediately on the current thread. + * + * @return {@link ImmediateScheduler} instance + */ + @Deprecated + public static Scheduler immediate() { + return rx.schedulers.ImmediateScheduler.getInstance(); + } + + /** + * {@link Scheduler} that queues work on the current thread to be executed after the current work completes. + * + * @return {@link CurrentThreadScheduler} instance + */ + @Deprecated + public static Scheduler currentThread() { + return rx.schedulers.CurrentThreadScheduler.getInstance(); + } + + /** + * {@link Scheduler} that creates a new {@link Thread} for each unit of work. + * + * @return {@link NewThreadScheduler} instance + */ + @Deprecated + public static Scheduler newThread() { + return rx.schedulers.NewThreadScheduler.getInstance(); + } + + /** + * {@link Scheduler} that queues work on an {@link Executor}. + *

+ * Note that this does not support scheduled actions with a delay. + * + * @return {@link ExecutorScheduler} instance + */ + @Deprecated + public static Scheduler executor(Executor executor) { + return new rx.schedulers.ExecutorScheduler(executor); + } + + /** + * {@link Scheduler} that queues work on an {@link ScheduledExecutorService}. + * + * @return {@link ExecutorScheduler} instance + */ + @Deprecated + public static Scheduler executor(ScheduledExecutorService executor) { + return new rx.schedulers.ExecutorScheduler(executor); + } + + /** + * {@link Scheduler} intended for computational work. + *

+ * The implementation is backed by a {@link ScheduledExecutorService} thread-pool sized to the number of CPU cores. + *

+ * This can be used for event-loops, processing callbacks and other computational work. + *

+ * Do not perform IO-bound work on this scheduler. Use {@link #threadPoolForComputation()} instead. + * + * @return {@link ExecutorScheduler} for computation-bound work. + */ + @Deprecated + public static Scheduler threadPoolForComputation() { + return rx.schedulers.Schedulers.threadPoolForComputation(); + } + + /** + * {@link Scheduler} intended for IO-bound work. + *

+ * The implementation is backed by an {@link Executor} thread-pool that will grow as needed. + *

+ * This can be used for asynchronously performing blocking IO. + *

+ * Do not perform computational work on this scheduler. Use {@link #threadPoolForComputation()} instead. + * + * @return {@link ExecutorScheduler} for IO-bound work. + */ + @Deprecated + public static Scheduler threadPoolForIO() { + return rx.schedulers.Schedulers.threadPoolForIO(); + } + +} diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java new file mode 100644 index 0000000000..fbf3e76b7d --- /dev/null +++ b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java @@ -0,0 +1,14 @@ +package rx.concurrency; + +/** + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.TestScheduler} instead. This will be removed before 1.0 release. + */ +@Deprecated +public class TestScheduler extends rx.schedulers.TestScheduler { + + public TestScheduler() { + } + +} diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java similarity index 100% rename from rxjava-core/src/main/java/rx/operators/OperationParallelMergeTest.java rename to rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java diff --git a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java similarity index 100% rename from rxjava-core/src/main/java/rx/schedulers/CurrentThreadSchedulerTest.java rename to rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java similarity index 100% rename from rxjava-core/src/main/java/rx/schedulers/ImmediateSchedulerTest.java rename to rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java From 99ceebe86c99dd9a66c7b244511b6dc8996aef40 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:48:15 -0800 Subject: [PATCH 073/441] rx.concurrent -> rx.schedulers for Android and Swing modules --- .../concurrency/AndroidSchedulers.java | 47 +-- .../concurrency/HandlerThreadScheduler.java | 127 +------- .../android/schedulers/AndroidSchedulers.java | 51 ++++ .../schedulers/HandlerThreadScheduler.java | 132 +++++++++ .../OperationObserveFromAndroidComponent.java | 4 +- .../java/rx/concurrency/SwingScheduler.java | 261 +---------------- .../java/rx/schedulers/SwingScheduler.java | 274 ++++++++++++++++++ .../SchedulerUnsubscribeTest.java | 0 8 files changed, 490 insertions(+), 406 deletions(-) create mode 100644 rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/AndroidSchedulers.java create mode 100644 rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java create mode 100644 rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java rename rxjava-core/src/test/java/rx/{concurrency => schedulers}/SchedulerUnsubscribeTest.java (100%) diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java index 0b238b1644..982a80bdf6 100644 --- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java @@ -1,51 +1,24 @@ -/** - * 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.android.concurrency; -import android.os.Handler; -import android.os.Looper; import rx.Scheduler; +import android.os.Handler; /** - * Schedulers that have Android specific functionality + * Deprecated. Package changed from rx.android.concurrency to rx.android.schedulers. + * + * @deprecated Use {@link rx.android.schedulers.AndroidSchedulers} instead. This will be removed before 1.0 release. */ +@Deprecated public class AndroidSchedulers { - private static final Scheduler MAIN_THREAD_SCHEDULER = - new HandlerThreadScheduler(new Handler(Looper.getMainLooper())); - - private AndroidSchedulers(){ - - } - - /** - * {@link Scheduler} which uses the provided {@link Handler} to execute an action - * @param handler The handler that will be used when executing the action - * @return A handler based scheduler - */ + @Deprecated public static Scheduler handlerThread(final Handler handler) { - return new HandlerThreadScheduler(handler); + return rx.android.schedulers.AndroidSchedulers.handlerThread(handler); } - /** - * {@link Scheduler} which will execute an action on the main Android UI thread. - * - * @return A Main {@link Looper} based scheduler - */ + @Deprecated public static Scheduler mainThread() { - return MAIN_THREAD_SCHEDULER; + return rx.android.schedulers.AndroidSchedulers.mainThread(); } + } diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java index ae01d17c1a..8def41024f 100644 --- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java @@ -1,132 +1,17 @@ -/** - * 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.android.concurrency; import android.os.Handler; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.annotation.Config; - -import rx.Scheduler; -import rx.Subscription; -import rx.operators.SafeObservableSubscription; -import rx.util.functions.Func2; - -import java.util.concurrent.TimeUnit; - -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; - /** - * Schedules actions to run on an Android Handler thread. + * Deprecated. Package changed from rx.android.concurrency to rx.android.schedulers. + * + * @deprecated Use {@link rx.android.schedulers.HandlerThreadScheduler} instead. This will be removed before 1.0 release. */ -public class HandlerThreadScheduler extends Scheduler { +@Deprecated +public class HandlerThreadScheduler extends rx.android.schedulers.HandlerThreadScheduler { - private final Handler handler; - - /** - * Constructs a {@link HandlerThreadScheduler} using the given {@link Handler} - * @param handler {@link Handler} to use when scheduling actions - */ public HandlerThreadScheduler(Handler handler) { - this.handler = handler; - } - - /** - * Calls {@link HandlerThreadScheduler#schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)} - * with a delay of zero milliseconds. - * - * See {@link #schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)} - */ - @Override - public Subscription schedule(final T state, final Func2 action) { - return schedule(state, action, 0L, TimeUnit.MILLISECONDS); - } - - /** - * Calls {@link Handler#postDelayed(Runnable, long)} with a runnable that executes the given action. - * @param state - * State to pass into the action. - * @param action - * Action to schedule. - * @param delayTime - * Time the action is to be delayed before executing. - * @param unit - * Time unit of the delay time. - * @return A Subscription from which one can unsubscribe from. - */ - @Override - public Subscription schedule(final T state, final Func2 action, long delayTime, TimeUnit unit) { - final SafeObservableSubscription subscription = new SafeObservableSubscription(); - final Scheduler _scheduler = this; - handler.postDelayed(new Runnable() { - @Override - public void run() { - subscription.wrap(action.call(_scheduler, state)); - } - }, unit.toMillis(delayTime)); - return subscription; + super(handler); } - @RunWith(RobolectricTestRunner.class) - @Config(manifest=Config.NONE) - public static final class UnitTest { - - @Test - public void shouldScheduleImmediateActionOnHandlerThread() { - final Handler handler = mock(Handler.class); - final Object state = new Object(); - @SuppressWarnings("unchecked") - final Func2 action = mock(Func2.class); - - Scheduler scheduler = new HandlerThreadScheduler(handler); - scheduler.schedule(state, action); - - // verify that we post to the given Handler - ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class); - verify(handler).postDelayed(runnable.capture(), eq(0L)); - - // verify that the given handler delegates to our action - runnable.getValue().run(); - verify(action).call(scheduler, state); - } - - @Test - public void shouldScheduleDelayedActionOnHandlerThread() { - final Handler handler = mock(Handler.class); - final Object state = new Object(); - @SuppressWarnings("unchecked") - final Func2 action = mock(Func2.class); - - Scheduler scheduler = new HandlerThreadScheduler(handler); - scheduler.schedule(state, action, 1L, TimeUnit.SECONDS); - - // verify that we post to the given Handler - ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class); - verify(handler).postDelayed(runnable.capture(), eq(1000L)); - - // verify that the given handler delegates to our action - runnable.getValue().run(); - verify(action).call(scheduler, state); - } - } } - - diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/AndroidSchedulers.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/AndroidSchedulers.java new file mode 100644 index 0000000000..5120c8e848 --- /dev/null +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/AndroidSchedulers.java @@ -0,0 +1,51 @@ +/** + * 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.android.schedulers; + +import android.os.Handler; +import android.os.Looper; +import rx.Scheduler; + +/** + * Schedulers that have Android specific functionality + */ +public class AndroidSchedulers { + + private static final Scheduler MAIN_THREAD_SCHEDULER = + new HandlerThreadScheduler(new Handler(Looper.getMainLooper())); + + private AndroidSchedulers(){ + + } + + /** + * {@link Scheduler} which uses the provided {@link Handler} to execute an action + * @param handler The handler that will be used when executing the action + * @return A handler based scheduler + */ + public static Scheduler handlerThread(final Handler handler) { + return new HandlerThreadScheduler(handler); + } + + /** + * {@link Scheduler} which will execute an action on the main Android UI thread. + * + * @return A Main {@link Looper} based scheduler + */ + public static Scheduler mainThread() { + return MAIN_THREAD_SCHEDULER; + } +} diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java new file mode 100644 index 0000000000..8535dda295 --- /dev/null +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java @@ -0,0 +1,132 @@ +/** + * 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.android.schedulers; + +import android.os.Handler; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.annotation.Config; + +import rx.Scheduler; +import rx.Subscription; +import rx.operators.SafeObservableSubscription; +import rx.util.functions.Func2; + +import java.util.concurrent.TimeUnit; + +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +/** + * Schedules actions to run on an Android Handler thread. + */ +public class HandlerThreadScheduler extends Scheduler { + + private final Handler handler; + + /** + * Constructs a {@link HandlerThreadScheduler} using the given {@link Handler} + * @param handler {@link Handler} to use when scheduling actions + */ + public HandlerThreadScheduler(Handler handler) { + this.handler = handler; + } + + /** + * Calls {@link HandlerThreadScheduler#schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)} + * with a delay of zero milliseconds. + * + * See {@link #schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)} + */ + @Override + public Subscription schedule(final T state, final Func2 action) { + return schedule(state, action, 0L, TimeUnit.MILLISECONDS); + } + + /** + * Calls {@link Handler#postDelayed(Runnable, long)} with a runnable that executes the given action. + * @param state + * State to pass into the action. + * @param action + * Action to schedule. + * @param delayTime + * Time the action is to be delayed before executing. + * @param unit + * Time unit of the delay time. + * @return A Subscription from which one can unsubscribe from. + */ + @Override + public Subscription schedule(final T state, final Func2 action, long delayTime, TimeUnit unit) { + final SafeObservableSubscription subscription = new SafeObservableSubscription(); + final Scheduler _scheduler = this; + handler.postDelayed(new Runnable() { + @Override + public void run() { + subscription.wrap(action.call(_scheduler, state)); + } + }, unit.toMillis(delayTime)); + return subscription; + } + + @RunWith(RobolectricTestRunner.class) + @Config(manifest=Config.NONE) + public static final class UnitTest { + + @Test + public void shouldScheduleImmediateActionOnHandlerThread() { + final Handler handler = mock(Handler.class); + final Object state = new Object(); + @SuppressWarnings("unchecked") + final Func2 action = mock(Func2.class); + + Scheduler scheduler = new HandlerThreadScheduler(handler); + scheduler.schedule(state, action); + + // verify that we post to the given Handler + ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class); + verify(handler).postDelayed(runnable.capture(), eq(0L)); + + // verify that the given handler delegates to our action + runnable.getValue().run(); + verify(action).call(scheduler, state); + } + + @Test + public void shouldScheduleDelayedActionOnHandlerThread() { + final Handler handler = mock(Handler.class); + final Object state = new Object(); + @SuppressWarnings("unchecked") + final Func2 action = mock(Func2.class); + + Scheduler scheduler = new HandlerThreadScheduler(handler); + scheduler.schedule(state, action, 1L, TimeUnit.SECONDS); + + // verify that we post to the given Handler + ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class); + verify(handler).postDelayed(runnable.capture(), eq(1000L)); + + // verify that the given handler delegates to our action + runnable.getValue().run(); + verify(action).call(scheduler, state); + } + } +} + + diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java index cfce38f8bb..06b22dae5c 100644 --- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java @@ -31,12 +31,12 @@ import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; import org.robolectric.annotation.Config; + import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.android.concurrency.AndroidSchedulers; +import rx.android.schedulers.AndroidSchedulers; import rx.subjects.PublishSubject; - import android.app.Activity; import android.app.Fragment; import android.os.Looper; diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java index f2d10d69b0..c9fcb18a1f 100644 --- a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java +++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java @@ -1,274 +1,43 @@ -/** - * 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.concurrency; -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; - -import java.awt.EventQueue; -import java.awt.event.ActionEvent; -import java.awt.event.ActionListener; -import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; - -import javax.swing.SwingUtilities; -import javax.swing.Timer; - -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.ExpectedException; -import org.mockito.InOrder; import rx.Scheduler; import rx.Subscription; -import rx.subscriptions.CompositeSubscription; -import rx.subscriptions.Subscriptions; -import rx.util.functions.Action0; import rx.util.functions.Func2; /** - * Executes work on the Swing UI thread. - * This scheduler should only be used with actions that execute quickly. + * Deprecated. Package changed from rx.concurrency to rx.schedulers. + * + * @deprecated Use {@link rx.schedulers.SwingScheduler} instead. This will be removed before 1.0 release. */ -public final class SwingScheduler extends Scheduler { - private static final SwingScheduler INSTANCE = new SwingScheduler(); +@Deprecated +public class SwingScheduler extends Scheduler { + + private final static SwingScheduler INSTANCE = new SwingScheduler(); public static SwingScheduler getInstance() { return INSTANCE; } + private final rx.schedulers.SwingScheduler actual; + private SwingScheduler() { + actual = rx.schedulers.SwingScheduler.getInstance(); } @Override - public Subscription schedule(final T state, final Func2 action) { - final AtomicReference sub = new AtomicReference(); - EventQueue.invokeLater(new Runnable() { - @Override - public void run() { - sub.set(action.call(SwingScheduler.this, state)); - } - }); - return Subscriptions.create(new Action0() { - @Override - public void call() { - Subscription subscription = sub.get(); - if (subscription != null) { - subscription.unsubscribe(); - } - } - }); + public Subscription schedule(T state, Func2 action) { + return actual.schedule(state, action); } @Override - public Subscription schedule(final T state, final Func2 action, long dueTime, TimeUnit unit) { - final AtomicReference sub = new AtomicReference(); - long delay = unit.toMillis(dueTime); - assertThatTheDelayIsValidForTheSwingTimer(delay); - - class ExecuteOnceAction implements ActionListener { - private Timer timer; - - private void setTimer(Timer timer) { - this.timer = timer; - } - - @Override - public void actionPerformed(ActionEvent e) { - timer.stop(); - sub.set(action.call(SwingScheduler.this, state)); - } - } - - ExecuteOnceAction executeOnce = new ExecuteOnceAction(); - final Timer timer = new Timer((int) delay, executeOnce); - executeOnce.setTimer(timer); - timer.start(); - - return Subscriptions.create(new Action0() { - @Override - public void call() { - timer.stop(); - - Subscription subscription = sub.get(); - if (subscription != null) { - subscription.unsubscribe(); - } - } - }); + public Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) { + return actual.schedule(state, action, delayTime, unit); } - @Override public Subscription schedulePeriodically(T state, final Func2 action, long initialDelay, long period, TimeUnit unit) { - final AtomicReference timer = new AtomicReference(); - - final long delay = unit.toMillis(period); - assertThatTheDelayIsValidForTheSwingTimer(delay); - - final CompositeSubscription subscriptions = new CompositeSubscription(); - final Func2 initialAction = new Func2() { - @Override - public Subscription call(final Scheduler scheduler, final T state0) { - // start timer for periodic execution, collect subscriptions - timer.set(new Timer((int) delay, new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - subscriptions.add(action.call(scheduler, state0)); - } - })); - timer.get().start(); - - return action.call(scheduler, state0); - } - }; - subscriptions.add(schedule(state, initialAction, initialDelay, unit)); - - subscriptions.add(Subscriptions.create(new Action0() { - @Override - public void call() { - // in addition to all the individual unsubscriptions, stop the timer on unsubscribing - Timer maybeTimer = timer.get(); - if (maybeTimer != null) { - maybeTimer.stop(); - } - } - })); - - return subscriptions; + return actual.schedulePeriodically(state, action, initialDelay, period, unit); } - private static void assertThatTheDelayIsValidForTheSwingTimer(long delay) { - if (delay < 0 || delay > Integer.MAX_VALUE) { - throw new IllegalArgumentException(String.format("The swing timer only accepts non-negative delays up to %d milliseconds.", Integer.MAX_VALUE)); - } - } - - public static class UnitTest { - @Rule - public ExpectedException exception = ExpectedException.none(); - - @Test - public void testInvalidDelayValues() { - final SwingScheduler scheduler = new SwingScheduler(); - final Action0 action = mock(Action0.class); - - exception.expect(IllegalArgumentException.class); - scheduler.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS); - - exception.expect(IllegalArgumentException.class); - scheduler.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS); - - exception.expect(IllegalArgumentException.class); - scheduler.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS); - - exception.expect(IllegalArgumentException.class); - scheduler.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS); - } - - @Test - public void testPeriodicScheduling() throws Exception { - final SwingScheduler scheduler = new SwingScheduler(); - - final CountDownLatch latch = new CountDownLatch(4); - - final Action0 innerAction = mock(Action0.class); - final Action0 action = new Action0() { - @Override - public void call() { - try { - innerAction.call(); - assertTrue(SwingUtilities.isEventDispatchThread()); - } finally { - latch.countDown(); - } - } - }; - - Subscription sub = scheduler.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS); - - if (!latch.await(5000, TimeUnit.MILLISECONDS)) { - fail("timed out waiting for tasks to execute"); - } - - sub.unsubscribe(); - waitForEmptyEventQueue(); - verify(innerAction, times(4)).call(); - } - - @Test - public void testNestedActions() throws Exception { - final SwingScheduler scheduler = new SwingScheduler(); - - final Action0 firstStepStart = mock(Action0.class); - final Action0 firstStepEnd = mock(Action0.class); - - final Action0 secondStepStart = mock(Action0.class); - final Action0 secondStepEnd = mock(Action0.class); - - final Action0 thirdStepStart = mock(Action0.class); - final Action0 thirdStepEnd = mock(Action0.class); - - final Action0 firstAction = new Action0() { - @Override - public void call() { - assertTrue(SwingUtilities.isEventDispatchThread()); - firstStepStart.call(); - firstStepEnd.call(); - } - }; - final Action0 secondAction = new Action0() { - @Override - public void call() { - assertTrue(SwingUtilities.isEventDispatchThread()); - secondStepStart.call(); - scheduler.schedule(firstAction); - secondStepEnd.call(); - } - }; - final Action0 thirdAction = new Action0() { - @Override - public void call() { - assertTrue(SwingUtilities.isEventDispatchThread()); - thirdStepStart.call(); - scheduler.schedule(secondAction); - thirdStepEnd.call(); - } - }; - - InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd); - - scheduler.schedule(thirdAction); - waitForEmptyEventQueue(); - - inOrder.verify(thirdStepStart, times(1)).call(); - inOrder.verify(thirdStepEnd, times(1)).call(); - inOrder.verify(secondStepStart, times(1)).call(); - inOrder.verify(secondStepEnd, times(1)).call(); - inOrder.verify(firstStepStart, times(1)).call(); - inOrder.verify(firstStepEnd, times(1)).call(); - } - - private static void waitForEmptyEventQueue() throws Exception { - EventQueue.invokeAndWait(new Runnable() { - @Override - public void run() { - // nothing to do, we're just waiting here for the event queue to be emptied - } - }); - } - } } diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java new file mode 100644 index 0000000000..7ce2c4e2d1 --- /dev/null +++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java @@ -0,0 +1,274 @@ +/** + * 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.schedulers; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import java.awt.EventQueue; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +import javax.swing.SwingUtilities; +import javax.swing.Timer; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.mockito.InOrder; + +import rx.Scheduler; +import rx.Subscription; +import rx.subscriptions.CompositeSubscription; +import rx.subscriptions.Subscriptions; +import rx.util.functions.Action0; +import rx.util.functions.Func2; + +/** + * Executes work on the Swing UI thread. + * This scheduler should only be used with actions that execute quickly. + */ +public final class SwingScheduler extends Scheduler { + private static final SwingScheduler INSTANCE = new SwingScheduler(); + + public static SwingScheduler getInstance() { + return INSTANCE; + } + + private SwingScheduler() { + } + + @Override + public Subscription schedule(final T state, final Func2 action) { + final AtomicReference sub = new AtomicReference(); + EventQueue.invokeLater(new Runnable() { + @Override + public void run() { + sub.set(action.call(SwingScheduler.this, state)); + } + }); + return Subscriptions.create(new Action0() { + @Override + public void call() { + Subscription subscription = sub.get(); + if (subscription != null) { + subscription.unsubscribe(); + } + } + }); + } + + @Override + public Subscription schedule(final T state, final Func2 action, long dueTime, TimeUnit unit) { + final AtomicReference sub = new AtomicReference(); + long delay = unit.toMillis(dueTime); + assertThatTheDelayIsValidForTheSwingTimer(delay); + + class ExecuteOnceAction implements ActionListener { + private Timer timer; + + private void setTimer(Timer timer) { + this.timer = timer; + } + + @Override + public void actionPerformed(ActionEvent e) { + timer.stop(); + sub.set(action.call(SwingScheduler.this, state)); + } + } + + ExecuteOnceAction executeOnce = new ExecuteOnceAction(); + final Timer timer = new Timer((int) delay, executeOnce); + executeOnce.setTimer(timer); + timer.start(); + + return Subscriptions.create(new Action0() { + @Override + public void call() { + timer.stop(); + + Subscription subscription = sub.get(); + if (subscription != null) { + subscription.unsubscribe(); + } + } + }); + } + + @Override + public Subscription schedulePeriodically(T state, final Func2 action, long initialDelay, long period, TimeUnit unit) { + final AtomicReference timer = new AtomicReference(); + + final long delay = unit.toMillis(period); + assertThatTheDelayIsValidForTheSwingTimer(delay); + + final CompositeSubscription subscriptions = new CompositeSubscription(); + final Func2 initialAction = new Func2() { + @Override + public Subscription call(final Scheduler scheduler, final T state0) { + // start timer for periodic execution, collect subscriptions + timer.set(new Timer((int) delay, new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + subscriptions.add(action.call(scheduler, state0)); + } + })); + timer.get().start(); + + return action.call(scheduler, state0); + } + }; + subscriptions.add(schedule(state, initialAction, initialDelay, unit)); + + subscriptions.add(Subscriptions.create(new Action0() { + @Override + public void call() { + // in addition to all the individual unsubscriptions, stop the timer on unsubscribing + Timer maybeTimer = timer.get(); + if (maybeTimer != null) { + maybeTimer.stop(); + } + } + })); + + return subscriptions; + } + + private static void assertThatTheDelayIsValidForTheSwingTimer(long delay) { + if (delay < 0 || delay > Integer.MAX_VALUE) { + throw new IllegalArgumentException(String.format("The swing timer only accepts non-negative delays up to %d milliseconds.", Integer.MAX_VALUE)); + } + } + + public static class UnitTest { + @Rule + public ExpectedException exception = ExpectedException.none(); + + @Test + public void testInvalidDelayValues() { + final SwingScheduler scheduler = new SwingScheduler(); + final Action0 action = mock(Action0.class); + + exception.expect(IllegalArgumentException.class); + scheduler.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS); + + exception.expect(IllegalArgumentException.class); + scheduler.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS); + + exception.expect(IllegalArgumentException.class); + scheduler.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS); + + exception.expect(IllegalArgumentException.class); + scheduler.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS); + } + + @Test + public void testPeriodicScheduling() throws Exception { + final SwingScheduler scheduler = new SwingScheduler(); + + final CountDownLatch latch = new CountDownLatch(4); + + final Action0 innerAction = mock(Action0.class); + final Action0 action = new Action0() { + @Override + public void call() { + try { + innerAction.call(); + assertTrue(SwingUtilities.isEventDispatchThread()); + } finally { + latch.countDown(); + } + } + }; + + Subscription sub = scheduler.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS); + + if (!latch.await(5000, TimeUnit.MILLISECONDS)) { + fail("timed out waiting for tasks to execute"); + } + + sub.unsubscribe(); + waitForEmptyEventQueue(); + verify(innerAction, times(4)).call(); + } + + @Test + public void testNestedActions() throws Exception { + final SwingScheduler scheduler = new SwingScheduler(); + + final Action0 firstStepStart = mock(Action0.class); + final Action0 firstStepEnd = mock(Action0.class); + + final Action0 secondStepStart = mock(Action0.class); + final Action0 secondStepEnd = mock(Action0.class); + + final Action0 thirdStepStart = mock(Action0.class); + final Action0 thirdStepEnd = mock(Action0.class); + + final Action0 firstAction = new Action0() { + @Override + public void call() { + assertTrue(SwingUtilities.isEventDispatchThread()); + firstStepStart.call(); + firstStepEnd.call(); + } + }; + final Action0 secondAction = new Action0() { + @Override + public void call() { + assertTrue(SwingUtilities.isEventDispatchThread()); + secondStepStart.call(); + scheduler.schedule(firstAction); + secondStepEnd.call(); + } + }; + final Action0 thirdAction = new Action0() { + @Override + public void call() { + assertTrue(SwingUtilities.isEventDispatchThread()); + thirdStepStart.call(); + scheduler.schedule(secondAction); + thirdStepEnd.call(); + } + }; + + InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd); + + scheduler.schedule(thirdAction); + waitForEmptyEventQueue(); + + inOrder.verify(thirdStepStart, times(1)).call(); + inOrder.verify(thirdStepEnd, times(1)).call(); + inOrder.verify(secondStepStart, times(1)).call(); + inOrder.verify(secondStepEnd, times(1)).call(); + inOrder.verify(firstStepStart, times(1)).call(); + inOrder.verify(firstStepEnd, times(1)).call(); + } + + private static void waitForEmptyEventQueue() throws Exception { + EventQueue.invokeAndWait(new Runnable() { + @Override + public void run() { + // nothing to do, we're just waiting here for the event queue to be emptied + } + }); + } + } +} diff --git a/rxjava-core/src/test/java/rx/concurrency/SchedulerUnsubscribeTest.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java similarity index 100% rename from rxjava-core/src/test/java/rx/concurrency/SchedulerUnsubscribeTest.java rename to rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java From fc1c52054b4a757aeead74cf54fec170efcfaa27 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:52:48 -0800 Subject: [PATCH 074/441] Migrate code to use rx.schedulers instead of rx.concurrency Unit tests passed before and after (did change in multiple steps to assert unit test pass against rx.concurrency before migrating to rx.schedulers). --- .../src/test/groovy/rx/lang/groovy/TestParallel.groovy | 2 +- .../src/main/scala/rx/lang/scala/Scheduler.scala | 10 +++++----- .../lang/scala/schedulers/CurrentThreadScheduler.scala | 2 +- .../rx/lang/scala/schedulers/ExecutorScheduler.scala | 2 +- .../rx/lang/scala/schedulers/ImmediateScheduler.scala | 2 +- .../rx/lang/scala/schedulers/NewThreadScheduler.scala | 2 +- .../schedulers/ScheduledExecutorServiceScheduler.scala | 2 +- .../scala/rx/lang/scala/schedulers/TestScheduler.scala | 4 ++-- .../schedulers/ThreadPoolForComputationScheduler.scala | 2 +- .../scala/schedulers/ThreadPoolForIOScheduler.scala | 2 +- rxjava-core/src/test/java/rx/EventStream.java | 2 +- rxjava-core/src/test/java/rx/ObservableTests.java | 2 +- rxjava-core/src/test/java/rx/ObserveOnTests.java | 2 +- rxjava-core/src/test/java/rx/RefCountTests.java | 2 +- rxjava-core/src/test/java/rx/SchedulersTest.java | 4 ++-- rxjava-core/src/test/java/rx/ThrottleFirstTests.java | 2 +- rxjava-core/src/test/java/rx/ThrottleLastTests.java | 2 +- .../src/test/java/rx/ThrottleWithTimeoutTests.java | 2 +- rxjava-core/src/test/java/rx/TimeoutTests.java | 2 +- .../src/test/java/rx/operators/OperationAmbTest.java | 2 +- .../test/java/rx/operators/OperationBufferTest.java | 2 +- .../test/java/rx/operators/OperationConcatTest.java | 2 +- .../test/java/rx/operators/OperationDebounceTest.java | 2 +- .../src/test/java/rx/operators/OperationDelayTest.java | 2 +- .../test/java/rx/operators/OperationDoOnEachTest.java | 2 +- .../test/java/rx/operators/OperationIntervalTest.java | 2 +- .../src/test/java/rx/operators/OperationMapTest.java | 2 +- .../src/test/java/rx/operators/OperationNextTest.java | 2 +- .../test/java/rx/operators/OperationObserveOnTest.java | 4 ++-- .../test/java/rx/operators/OperationSampleTest.java | 2 +- .../java/rx/operators/OperationSubscribeOnTest.java | 2 +- .../test/java/rx/operators/OperationSwitchTest.java | 2 +- .../java/rx/operators/OperationThrottleFirstTest.java | 2 +- .../java/rx/operators/OperationTimeIntervalTest.java | 2 +- .../test/java/rx/operators/OperationTimestampTest.java | 2 +- .../test/java/rx/operators/OperationWindowTest.java | 2 +- .../java/rx/schedulers/SchedulerUnsubscribeTest.java | 3 ++- .../src/test/java/rx/util/functions/AsyncTest.java | 2 +- 38 files changed, 46 insertions(+), 45 deletions(-) diff --git a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy index 509b7b0ca5..a54241b160 100644 --- a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy +++ b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy @@ -19,7 +19,7 @@ import org.junit.Test import rx.Observable import rx.Scheduler -import rx.concurrency.Schedulers +import rx.schedulers.Schedulers import rx.util.functions.Func1 class TestParallel { diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala index 8b4edde4fa..ead8054279 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala @@ -204,11 +204,11 @@ trait Scheduler { private [scala] object Scheduler { def apply(scheduler: rx.Scheduler): Scheduler = scheduler match { - case s: rx.concurrency.CurrentThreadScheduler => new CurrentThreadScheduler(s) - case s: rx.concurrency.ExecutorScheduler => new ExecutorScheduler(s) - case s: rx.concurrency.ImmediateScheduler => new ImmediateScheduler(s) - case s: rx.concurrency.NewThreadScheduler => new NewThreadScheduler(s) - case s: rx.concurrency.TestScheduler => new TestScheduler(s) + case s: rx.schedulers.CurrentThreadScheduler => new CurrentThreadScheduler(s) + case s: rx.schedulers.ExecutorScheduler => new ExecutorScheduler(s) + case s: rx.schedulers.ImmediateScheduler => new ImmediateScheduler(s) + case s: rx.schedulers.NewThreadScheduler => new NewThreadScheduler(s) + case s: rx.schedulers.TestScheduler => new TestScheduler(s) case s: rx.Scheduler => new Scheduler{ val asJavaScheduler = s } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala index f3a7898a30..688b1e86ca 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala @@ -23,7 +23,7 @@ object CurrentThreadScheduler { * Returns a [[rx.lang.scala.Scheduler]] that queues work on the current thread to be executed after the current work completes. */ def apply(): CurrentThreadScheduler = { - new CurrentThreadScheduler(rx.concurrency.Schedulers.currentThread()) + new CurrentThreadScheduler(rx.schedulers.Schedulers.currentThread()) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala index d718c58b55..72287939e8 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala @@ -26,7 +26,7 @@ object ExecutorScheduler { * Note that this does not support scheduled actions with a delay. */ def apply(executor: Executor): ExecutorScheduler = { - new ExecutorScheduler(rx.concurrency.Schedulers.executor(executor)) + new ExecutorScheduler(rx.schedulers.Schedulers.executor(executor)) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala index 7a066a3931..cc22456afa 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ImmediateScheduler.scala @@ -23,7 +23,7 @@ object ImmediateScheduler { * Returns a [[rx.lang.scala.Scheduler]] that executes work immediately on the current thread. */ def apply(): ImmediateScheduler = { - new ImmediateScheduler(rx.concurrency.Schedulers.immediate()) + new ImmediateScheduler(rx.schedulers.Schedulers.immediate()) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala index 674205ba07..1955035981 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala @@ -23,7 +23,7 @@ object NewThreadScheduler { * Returns a [[rx.lang.scala.Scheduler]] that creates a new {@link Thread} for each unit of work. */ def apply(): NewThreadScheduler = { - new NewThreadScheduler(rx.concurrency.Schedulers.newThread()) + new NewThreadScheduler(rx.schedulers.Schedulers.newThread()) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala index 20c4dc3544..8f64bb4f84 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala @@ -24,7 +24,7 @@ object ScheduledExecutorServiceScheduler { * Returns a [[rx.lang.scala.Scheduler]] that queues work on an `java.util.concurrent.ScheduledExecutorService`. */ def apply(executor: ScheduledExecutorService): ScheduledExecutorServiceScheduler = { - new ScheduledExecutorServiceScheduler(rx.concurrency.Schedulers.executor(executor)) + new ScheduledExecutorServiceScheduler(rx.schedulers.Schedulers.executor(executor)) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala index f8df7610b8..3d853f87e9 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala @@ -23,7 +23,7 @@ import rx.lang.scala.Scheduler */ object TestScheduler { def apply(): TestScheduler = { - new TestScheduler(new rx.concurrency.TestScheduler()) + new TestScheduler(new rx.schedulers.TestScheduler()) } } @@ -64,7 +64,7 @@ object TestScheduler { * } * }}} */ -class TestScheduler private[scala] (val asJavaScheduler: rx.concurrency.TestScheduler) extends Scheduler { +class TestScheduler private[scala] (val asJavaScheduler: rx.schedulers.TestScheduler) extends Scheduler { def advanceTimeBy(time: Duration) { asJavaScheduler.advanceTimeBy(time.length, time.unit) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala index b9e0791bef..38e321bc04 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala @@ -29,7 +29,7 @@ object ThreadPoolForComputationScheduler { * Do not perform IO-bound work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForIOScheduler]] instead. */ def apply(): ThreadPoolForComputationScheduler = { - new ThreadPoolForComputationScheduler(rx.concurrency.Schedulers.threadPoolForComputation()) + new ThreadPoolForComputationScheduler(rx.schedulers.Schedulers.threadPoolForComputation()) } } diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala index 63b7e6b659..e3fef92080 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala @@ -29,7 +29,7 @@ object ThreadPoolForIOScheduler { * Do not perform computational work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForComputationScheduler]] instead. */ def apply(): ThreadPoolForIOScheduler = { - new ThreadPoolForIOScheduler(rx.concurrency.Schedulers.threadPoolForIO()) + new ThreadPoolForIOScheduler(rx.schedulers.Schedulers.threadPoolForIO()) } } diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java index f32787bac1..f41e670923 100644 --- a/rxjava-core/src/test/java/rx/EventStream.java +++ b/rxjava-core/src/test/java/rx/EventStream.java @@ -20,7 +20,7 @@ import java.util.Map; import rx.Observable.OnSubscribeFunc; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subscriptions.BooleanSubscription; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index e4023f44ab..43b81195af 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -35,7 +35,7 @@ import org.mockito.MockitoAnnotations; import rx.Observable.OnSubscribeFunc; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.observables.ConnectableObservable; import rx.subscriptions.BooleanSubscription; import rx.subscriptions.Subscriptions; diff --git a/rxjava-core/src/test/java/rx/ObserveOnTests.java b/rxjava-core/src/test/java/rx/ObserveOnTests.java index 57d13c3585..3f9e474787 100644 --- a/rxjava-core/src/test/java/rx/ObserveOnTests.java +++ b/rxjava-core/src/test/java/rx/ObserveOnTests.java @@ -21,7 +21,7 @@ import org.junit.Test; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Action1; import rx.util.functions.Func1; diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java index b83e94fcae..3f02933a80 100644 --- a/rxjava-core/src/test/java/rx/RefCountTests.java +++ b/rxjava-core/src/test/java/rx/RefCountTests.java @@ -27,7 +27,7 @@ import org.junit.Test; import org.mockito.MockitoAnnotations; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; import rx.util.functions.Action1; diff --git a/rxjava-core/src/test/java/rx/SchedulersTest.java b/rxjava-core/src/test/java/rx/SchedulersTest.java index c9d97054d0..62e74f5798 100644 --- a/rxjava-core/src/test/java/rx/SchedulersTest.java +++ b/rxjava-core/src/test/java/rx/SchedulersTest.java @@ -31,8 +31,8 @@ import org.mockito.Mockito; import rx.Observable.OnSubscribeFunc; -import rx.concurrency.Schedulers; -import rx.concurrency.TestScheduler; +import rx.schedulers.Schedulers; +import rx.schedulers.TestScheduler; import rx.subscriptions.BooleanSubscription; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java index 655754d398..bbba421477 100644 --- a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java +++ b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.mockito.InOrder; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; public class ThrottleFirstTests { diff --git a/rxjava-core/src/test/java/rx/ThrottleLastTests.java b/rxjava-core/src/test/java/rx/ThrottleLastTests.java index c3a037a78c..94ec7051b2 100644 --- a/rxjava-core/src/test/java/rx/ThrottleLastTests.java +++ b/rxjava-core/src/test/java/rx/ThrottleLastTests.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.mockito.InOrder; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; public class ThrottleLastTests { diff --git a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java index ead4ddb24e..2e27c81cce 100644 --- a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java +++ b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.mockito.InOrder; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; public class ThrottleWithTimeoutTests { diff --git a/rxjava-core/src/test/java/rx/TimeoutTests.java b/rxjava-core/src/test/java/rx/TimeoutTests.java index 46a3620ce5..144824d222 100644 --- a/rxjava-core/src/test/java/rx/TimeoutTests.java +++ b/rxjava-core/src/test/java/rx/TimeoutTests.java @@ -30,7 +30,7 @@ import org.mockito.InOrder; import org.mockito.MockitoAnnotations; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; public class TimeoutTests { diff --git a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java index 784d686198..f6e5cd859c 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java @@ -29,7 +29,7 @@ import rx.Observable.OnSubscribeFunc; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.CompositeSubscription; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java index a2de69ed63..dc45a16a8f 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java @@ -34,7 +34,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; import rx.util.functions.Action1; diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java index 0f3f8f8866..24146ec131 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java @@ -32,7 +32,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.BooleanSubscription; public class OperationConcatTest { diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java index e831c7b829..9779239f95 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java @@ -27,7 +27,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java index 224a82be55..118094bffb 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java @@ -18,7 +18,7 @@ import rx.Observable; import rx.Observer; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.util.functions.Func1; public class OperationDelayTest { diff --git a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java index 6c1407ebea..e1e72a249a 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java @@ -33,7 +33,7 @@ import rx.Observable; import rx.Observer; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Func1; import rx.util.functions.Func2; import rx.util.functions.Action1; diff --git a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java index 293ff236c9..23c786fc89 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java @@ -27,7 +27,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.observables.ConnectableObservable; public class OperationIntervalTest { diff --git a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java index 175cd66f75..463b2dca7a 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java @@ -33,7 +33,7 @@ import rx.Observable; import rx.Observer; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Func1; import rx.util.functions.Func2; diff --git a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java index 140cc0560c..8a5de26d1d 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java @@ -30,7 +30,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.subjects.PublishSubject; import rx.subjects.Subject; import rx.subscriptions.Subscriptions; diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java index 63fa0e4f27..69fa6b1718 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java @@ -30,8 +30,8 @@ import rx.Observable; import rx.Observer; -import rx.concurrency.Schedulers; -import rx.concurrency.TestScheduler; +import rx.schedulers.Schedulers; +import rx.schedulers.TestScheduler; import rx.util.functions.Action1; public class OperationObserveOnTest { diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java index 18316889c1..58c98895ec 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java @@ -26,7 +26,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java index 635d4d8755..3f605abf97 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java @@ -25,7 +25,7 @@ import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.test.OperatorTester; import rx.util.functions.Action0; import rx.util.functions.Func2; diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java index fa38f02ff8..8afa5557f1 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java @@ -27,7 +27,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java index ad58e13604..682f030529 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java @@ -27,7 +27,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java index 056b97bf11..c71ade0166 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java @@ -27,7 +27,7 @@ import rx.Observable; import rx.Observer; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; import rx.util.TimeInterval; diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java index 9794b6c7f5..90baedd3dc 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java @@ -24,7 +24,7 @@ import org.mockito.MockitoAnnotations; import rx.Observable; import rx.Observer; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; import rx.util.Timestamped; diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java index 6eff582878..180179a902 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java @@ -28,7 +28,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.concurrency.TestScheduler; +import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; import rx.util.functions.Action1; diff --git a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java index a89da84304..123e22ac00 100644 --- a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java +++ b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java @@ -1,4 +1,4 @@ -package rx.concurrency; +package rx.schedulers; import static org.junit.Assert.*; @@ -11,6 +11,7 @@ import rx.Observable; import rx.Observer; import rx.Scheduler; +import rx.schedulers.Schedulers; import rx.operators.SafeObservableSubscription; import rx.util.functions.Func1; diff --git a/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java b/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java index cc76170894..05a75c4f85 100644 --- a/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java +++ b/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java @@ -27,7 +27,7 @@ import static org.mockito.Mockito.verify; import org.mockito.MockitoAnnotations; import rx.Observer; -import rx.concurrency.Schedulers; +import rx.schedulers.Schedulers; import rx.util.functions.Action0; import rx.util.functions.Action1; import rx.util.functions.Action2; From 71d25d127e63da0626b5d9c4bf7018610d89f254 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 15:55:19 -0800 Subject: [PATCH 075/441] Add Missing License Headers --- .../scala/examples/TestSchedulerExample.scala | 15 +++++++++++++++ .../scala/rx/lang/scala/JavaConversions.scala | 15 +++++++++++++++ .../rx/lang/scala/CompletenessTest.scala | 15 +++++++++++++++ .../scala/rx/lang/scala/ConstructorTest.scala | 15 +++++++++++++++ .../rx/lang/scala/NotificationTests.scala | 15 +++++++++++++++ .../scala/rx/lang/scala/ObservableTest.scala | 15 +++++++++++++++ .../scala/rx/lang/scala/SubjectTests.scala | 15 +++++++++++++++ .../rx/lang/scala/SubscriptionTests.scala | 15 +++++++++++++++ .../concurrency/AndroidSchedulers.java | 15 +++++++++++++++ .../concurrency/HandlerThreadScheduler.java | 15 +++++++++++++++ .../java/rx/observables/StringObservable.java | 15 +++++++++++++++ .../rx/observables/StringObservableTest.java | 15 +++++++++++++++ .../java/rx/concurrency/SwingScheduler.java | 15 +++++++++++++++ .../concurrency/CurrentThreadScheduler.java | 15 +++++++++++++++ .../rx/concurrency/ExecutorScheduler.java | 15 +++++++++++++++ .../rx/concurrency/ImmediateScheduler.java | 15 +++++++++++++++ .../rx/concurrency/NewThreadScheduler.java | 15 +++++++++++++++ .../main/java/rx/concurrency/Schedulers.java | 15 +++++++++++++++ .../java/rx/concurrency/TestScheduler.java | 15 +++++++++++++++ .../java/rx/operators/OperationDelayTest.java | 15 +++++++++++++++ .../rx/operators/OperationToMultimapTest.java | 19 ++++++++++++++----- .../operators/OperationZipTestCompletion.java | 15 +++++++++++++++ .../schedulers/SchedulerUnsubscribeTest.java | 15 +++++++++++++++ .../test/java/rx/util/AssertObservable.java | 15 +++++++++++++++ .../java/rx/util/AssertObservableTest.java | 15 +++++++++++++++ 25 files changed, 374 insertions(+), 5 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala index 2e53f1afe9..a48b8acb51 100644 --- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala +++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala.examples import scala.concurrent.duration.DurationInt diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala index cc380c463c..f36dc6b6dd 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala /** diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala index 41bbdca347..d4778d7d5e 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala import java.util.Calendar diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala index e2822405b2..6669db2f77 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala import scala.language.postfixOps import org.junit.Assert._ diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala index 759ca8b7ec..ea05faa942 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala index 0b755833da..39f863b4dd 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala import scala.concurrent.{Future, Await} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala index 50773d5582..f8d72e3520 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubjectTests.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala import org.junit.{Assert, Test} diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala index 71ea4d4a6e..b53d4fe265 100644 --- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala +++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriptionTests.scala @@ -1,3 +1,18 @@ +/** + * 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.lang.scala diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java index 982a80bdf6..f0e42f0d6d 100644 --- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/AndroidSchedulers.java @@ -1,3 +1,18 @@ +/** + * 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.android.concurrency; import rx.Scheduler; diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java index 8def41024f..7c117ccf44 100644 --- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java +++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.android.concurrency; import android.os.Handler; diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java index dfe7ca3e68..3bdb58a877 100644 --- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java +++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java @@ -1,3 +1,18 @@ +/** + * 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.observables; import java.nio.ByteBuffer; diff --git a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java index 8ced455f63..86a686958c 100644 --- a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java +++ b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java @@ -1,3 +1,18 @@ +/** + * 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.observables; import static org.junit.Assert.*; diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java index c9fcb18a1f..c6be1c55ec 100644 --- a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java +++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java index ed905af3e5..fe8ac26e0b 100644 --- a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java +++ b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java index ecfcddc286..2833a2072e 100644 --- a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java +++ b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.Executor; diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java index 001208d64c..f3bdf8aa8f 100644 --- a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java +++ b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java index fac4aa1fe0..a574442ba6 100644 --- a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java +++ b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.TimeUnit; diff --git a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java index a257d54e67..cdc9e1f6a3 100644 --- a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java +++ b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; import java.util.concurrent.Executor; diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java index fbf3e76b7d..e402e1b63e 100644 --- a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java +++ b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java @@ -1,3 +1,18 @@ +/** + * 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.concurrency; /** diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java index 118094bffb..538131731d 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java @@ -1,3 +1,18 @@ +/** + * 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 static org.mockito.Matchers.any; diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java index b254d93d2e..478f5f1da8 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java @@ -1,9 +1,18 @@ -/* - * To change this license header, choose License Headers in Project Properties. - * To change this template file, choose Tools | Templates - * and open the template in the editor. +/** + * 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 java.util.ArrayList; import java.util.Arrays; diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java index 3c0913f64d..23baf7652c 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java +++ b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java @@ -1,3 +1,18 @@ +/** + * 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 static org.mockito.Mockito.inOrder; diff --git a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java index 123e22ac00..ec51d7f977 100644 --- a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java +++ b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java @@ -1,3 +1,18 @@ +/** + * 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.schedulers; import static org.junit.Assert.*; diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java index 1bd34fcd23..196a12e92f 100644 --- a/rxjava-core/src/test/java/rx/util/AssertObservable.java +++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java @@ -1,3 +1,18 @@ +/** + * 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.util; import rx.Notification; diff --git a/rxjava-core/src/test/java/rx/util/AssertObservableTest.java b/rxjava-core/src/test/java/rx/util/AssertObservableTest.java index f2182bd8cf..a67381e89f 100644 --- a/rxjava-core/src/test/java/rx/util/AssertObservableTest.java +++ b/rxjava-core/src/test/java/rx/util/AssertObservableTest.java @@ -1,3 +1,18 @@ +/** + * 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.util; import org.junit.Test; From 212cec5b96b7d2babc52650afac6b2aa8c1571aa Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 17:39:58 -0800 Subject: [PATCH 076/441] ReplaySubject UnitTests Shows bug handling terminal state. --- .../java/rx/subjects/ReplaySubjectTest.java | 95 ++++++++++++++++++- 1 file changed, 91 insertions(+), 4 deletions(-) diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java index fef45ca63d..005b56ba5a 100644 --- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java +++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java @@ -1,12 +1,12 @@ /** * 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 - * + * + * 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. @@ -56,6 +56,93 @@ public void testCompleted() { assertCompletedObserver(o2); } + @Test + public void testCompletedStopsEmittingData() { + ReplaySubject channel = ReplaySubject.create(); + @SuppressWarnings("unchecked") + Observer observerA = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observerB = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observerC = mock(Observer.class); + @SuppressWarnings("unchecked") + Observer observerD = mock(Observer.class); + + Subscription a = channel.subscribe(observerA); + Subscription b = channel.subscribe(observerB); + + InOrder inOrderA = inOrder(observerA); + InOrder inOrderB = inOrder(observerB); + InOrder inOrderC = inOrder(observerC); + InOrder inOrderD = inOrder(observerD); + + channel.onNext(42); + + // both A and B should have received 42 from before subscription + inOrderA.verify(observerA).onNext(42); + inOrderB.verify(observerB).onNext(42); + + a.unsubscribe(); + + // a should receive no more + inOrderA.verifyNoMoreInteractions(); + + channel.onNext(4711); + + // only be should receive 4711 at this point + inOrderB.verify(observerB).onNext(4711); + + channel.onCompleted(); + + // B is subscribed so should receive onCompleted + inOrderB.verify(observerB).onCompleted(); + + Subscription c = channel.subscribe(observerC); + + // when C subscribes it should receive 42, 4711, onCompleted + inOrderC.verify(observerC).onNext(42); + inOrderC.verify(observerC).onNext(4711); + inOrderC.verify(observerC).onCompleted(); + + // if further events are propagated they should be ignored + channel.onNext(13); + channel.onNext(14); + channel.onNext(15); + channel.onError(new RuntimeException()); + + // a new subscription should only receive what was emitted prior to terminal state onCompleted + Subscription d = channel.subscribe(observerD); + + inOrderD.verify(observerD).onNext(42); + inOrderD.verify(observerD).onNext(4711); + inOrderD.verify(observerD).onCompleted(); + + Mockito.verifyNoMoreInteractions(observerA); + Mockito.verifyNoMoreInteractions(observerB); + Mockito.verifyNoMoreInteractions(observerC); + Mockito.verifyNoMoreInteractions(observerD); + + } + + @Test + public void testCompletedAfterError() { + ReplaySubject subject = ReplaySubject.create(); + + @SuppressWarnings("unchecked") + Observer aObserver = mock(Observer.class); + + subject.onNext("one"); + subject.onError(testException); + subject.onNext("two"); + subject.onCompleted(); + subject.onError(new RuntimeException()); + + subject.subscribe(aObserver); + verify(aObserver, times(1)).onNext("one"); + verify(aObserver, times(1)).onError(testException); + verifyNoMoreInteractions(aObserver); + } + private void assertCompletedObserver(Observer aObserver) { InOrder inOrder = inOrder(aObserver); From fcb76576f9d2ca4207f595b3cae187ebeace714f Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 10 Dec 2013 17:50:21 -0800 Subject: [PATCH 077/441] Fix #544 ReplaySubject emits items received after onError --- rxjava-core/src/main/java/rx/subjects/ReplaySubject.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java index 13d0cc3b57..c4985ba84a 100644 --- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java +++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java @@ -164,6 +164,9 @@ public void onError(Throwable e) public void onNext(T args) { synchronized (subscriptions) { + if (isDone) { + return; + } history.add(args); for (Observer observer : new ArrayList>(subscriptions.values())) { observer.onNext(args); From c799e525680e95744a129b427df16791bfad02a1 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Wed, 11 Dec 2013 11:05:44 +0800 Subject: [PATCH 078/441] Remove the Action0 overloads --- rxjava-core/src/main/java/rx/Observable.java | 37 ------- .../src/test/java/rx/ObservableTests.java | 101 ------------------ 2 files changed, 138 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 1eaa75611d..999d5b413a 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -6271,43 +6271,6 @@ public Observable> gro return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector)); } - /** - * Invokes the action asynchronously, surfacing the result through an observable sequence. - *

- * Note: The action is called immediately, not during the subscription of the resulting - * sequence. Multiple subscriptions to the resulting sequence can observe the - * action's outcome. - * - * @param action - * Action to run asynchronously. - * @return An observable sequence exposing a null value upon completion of the action, - * or an exception. - * @see MSDN: Observable.Start - */ - public static Observable start(Action0 action) { - return Async.toAsync(action).call(); - } - - /** - * Invokes the action asynchronously on the specified scheduler, surfacing the - * result through an observable sequence. - *

- * Note: The action is called immediately, not during the subscription of the resulting - * sequence. Multiple subscriptions to the resulting sequence can observe the - * action's outcome. - * - * @param action - * Action to run asynchronously. - * @param scheduler - * Scheduler to run the function on. - * @return An observable sequence exposing a null value upon completion of the action, - * or an exception. - * @see MSDN: Observable.Start - */ - public static Observable start(Action0 action, Scheduler scheduler) { - return Async.toAsync(action, scheduler).call(); - } - /** * Invokes the specified function asynchronously, surfacing the result through an observable sequence. *

diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index 6e703a57ce..9c5c7e1e49 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -951,107 +951,6 @@ public void testRangeWithScheduler() { inOrder.verifyNoMoreInteractions(); } - @Test - public void testStartWithAction() { - Action0 action = mock(Action0.class); - assertEquals(null, Observable.start(action).toBlockingObservable().single()); - } - - @Test(expected = RuntimeException.class) - public void testStartWithActionError() { - Action0 action = new Action0() { - @Override - public void call() { - throw new RuntimeException("Some error"); - } - }; - Observable.start(action).toBlockingObservable().single(); - } - - @Test - public void testStartWhenSubscribeRunBeforeAction() { - TestScheduler scheduler = new TestScheduler(); - - Action0 action = mock(Action0.class); - - Observable observable = Observable.start(action, scheduler); - - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - observable.subscribe(observer); - - InOrder inOrder = inOrder(observer); - inOrder.verifyNoMoreInteractions(); - - // Run action - scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); - - inOrder.verify(observer, times(1)).onNext(null); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testStartWhenSubscribeRunAfterAction() { - TestScheduler scheduler = new TestScheduler(); - - Action0 action = mock(Action0.class); - - Observable observable = Observable.start(action, scheduler); - - // Run action - scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); - - @SuppressWarnings("unchecked") - Observer observer = mock(Observer.class); - observable.subscribe(observer); - - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(null); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testStartWithActionAndMultipleObservers() { - TestScheduler scheduler = new TestScheduler(); - - Action0 action = mock(Action0.class); - - Observable observable = Observable.start(action, scheduler); - - scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); - - @SuppressWarnings("unchecked") - Observer observer1 = mock(Observer.class); - @SuppressWarnings("unchecked") - Observer observer2 = mock(Observer.class); - @SuppressWarnings("unchecked") - Observer observer3 = mock(Observer.class); - - observable.subscribe(observer1); - observable.subscribe(observer2); - observable.subscribe(observer3); - - InOrder inOrder; - inOrder = inOrder(observer1); - inOrder.verify(observer1, times(1)).onNext(null); - inOrder.verify(observer1, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - - inOrder = inOrder(observer2); - inOrder.verify(observer2, times(1)).onNext(null); - inOrder.verify(observer2, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - - inOrder = inOrder(observer3); - inOrder.verify(observer3, times(1)).onNext(null); - inOrder.verify(observer3, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - - verify(action, times(1)).call(); - } - @Test public void testStartWithFunc() { Func0 func = new Func0() { From 5f0dfc57a9b4e9c662f9de92373f87d08c2515f5 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Wed, 11 Dec 2013 19:22:41 +0100 Subject: [PATCH 079/441] Added op:join to concat objects with separator between elements. --- .../java/rx/observables/StringObservable.java | 55 ++++++++++++ .../rx/observables/StringObservableTest.java | 89 ++++++++++++++++++- 2 files changed, 142 insertions(+), 2 deletions(-) diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java index 3bdb58a877..8a22ef8cb7 100644 --- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java +++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java @@ -197,6 +197,7 @@ public byte[] call(String str) { */ public static Observable stringConcat(Observable src) { return src.aggregate(new Func2() { + @Override public String call(String a, String b) { return a + b; } @@ -267,4 +268,58 @@ private void output(String part) { } }); } + /** + * Concatenates the sequence of values by adding a separator + * between them and emitting the result once the source completes. + *

+ * The conversion from the value type to String is performed via + * {@link java.lang.String#valueOf(java.lang.Object)} calls. + *

+ * For example: + * 

+     * Observable<Object> source = Observable.from("a", 1, "c");
+     * Observable<String> result = join(source, ", ");
+     *
+ * + * will yield a single element equal to "a, 1, c". + * + * @param source the source sequence of CharSequence values + * @param separator the separator to a + * @return an Observable which emits a single String value having the concatenated + * values of the source observable with the separator between elements + */ + public static Observable join(final Observable source, final CharSequence separator) { + return Observable.create(new OnSubscribeFunc() { + + @Override + public Subscription onSubscribe(final Observer t1) { + return source.subscribe(new Observer() { + boolean mayAddSeparator; + StringBuilder b = new StringBuilder(); + @Override + public void onNext(T args) { + if (mayAddSeparator) { + b.append(separator); + } + mayAddSeparator = true; + b.append(String.valueOf(args)); + } + + @Override + public void onError(Throwable e) { + b = null; + t1.onError(e); + } + + @Override + public void onCompleted() { + String str = b.toString(); + b = null; + t1.onNext(str); + t1.onCompleted(); + } + }); + } + }); + } } diff --git a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java index 86a686958c..6b135894f9 100644 --- a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java +++ b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java @@ -23,10 +23,10 @@ import java.nio.charset.MalformedInputException; import org.junit.Test; +import static org.mockito.Mockito.*; import rx.Observable; -import rx.observables.BlockingObservable; -import rx.observables.StringObservable; +import rx.Observer; import rx.util.AssertObservable; public class StringObservableTest { @@ -127,4 +127,89 @@ public void testSplit(String message, String regex, int limit, Observable exp = Observable.from(parts); AssertObservable.assertObservableEqualsBlocking("when input is "+message+" and limit = "+ limit, exp, act); } + + @Test + public void testJoinMixed() { + Observable source = Observable.from("a", 1, "c"); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, times(1)).onNext("a, 1, c"); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testJoinWithEmptyString() { + Observable source = Observable.from("", "b", "c"); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, times(1)).onNext(", b, c"); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testJoinWithNull() { + Observable source = Observable.from("a", null, "c"); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, times(1)).onNext("a, null, c"); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testJoinSingle() { + Observable source = Observable.from("a"); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, times(1)).onNext("a"); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testJoinEmpty() { + Observable source = Observable.empty(); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, times(1)).onNext(""); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testJoinThrows() { + Observable source = Observable.concat(Observable.just("a"), Observable.error(new RuntimeException("Forced failure"))); + + Observable result = StringObservable.join(source, ", "); + + Observer observer = mock(Observer.class); + + result.subscribe(observer); + + verify(observer, never()).onNext("a"); + verify(observer, never()).onCompleted(); + verify(observer, times(1)).onError(any(Throwable.class)); + } } From ee148eaac4b7c608a7636bd6e3e6704d1cfd4c71 Mon Sep 17 00:00:00 2001 From: David Gross Date: Wed, 11 Dec 2013 14:38:13 -0800 Subject: [PATCH 080/441] Javadoc improvements: * consistent nomenclature * consistent/standard javadoc formatting * more-precise descriptions * timer() marble digram & wiki link * delay() marble diagram & wiki link --- rxjava-core/src/main/java/rx/Observable.java | 1485 +++++++++--------- 1 file changed, 774 insertions(+), 711 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index f68115199d..7d870b3788 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -413,7 +413,8 @@ public Subscription subscribe(final Action1 onNext, final Action1() { @@ -617,7 +618,7 @@ public static Observable create(OnSubscribeFunc func) { } /** - * Returns an Observable that emits no data to the {@link Observer} and + * Returns an Observable that emits no items to the {@link Observer} and * immediately invokes its {@link Observer#onCompleted onCompleted} method. *

* @@ -634,7 +635,7 @@ public static Observable empty() { } /** - * Returns an Observable that emits no data to the {@link Observer} and + * Returns an Observable that emits no items to the {@link Observer} and * immediately invokes its {@link Observer#onCompleted onCompleted} method * with the specified scheduler. *

@@ -715,7 +716,8 @@ public static Observable from(Iterable iterable) { } /** - * Converts an {@link Iterable} sequence into an Observable with the specified scheduler. + * Converts an {@link Iterable} sequence into an Observable with the + * specified scheduler. *

* * @@ -733,7 +735,7 @@ public static Observable from(Iterable iterable, Scheduler s } /** - * Converts an Array into an Observable. + * Converts an Array into an Observable that emits the items in the Array. *

* *

@@ -775,7 +777,7 @@ public static Observable from(T t1) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -798,7 +800,7 @@ public static Observable from(T t1, T t2) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -822,7 +824,7 @@ public static Observable from(T t1, T t2, T t3) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -847,7 +849,7 @@ public static Observable from(T t1, T t2, T t3, T t4) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -873,7 +875,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -900,7 +902,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -928,7 +930,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) { } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -957,7 +959,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -987,7 +989,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T } /** - * Converts a series of items into an Observable. + * Converts a series of items into an Observable that emits those items. *

* *

@@ -1018,7 +1020,7 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T } /** - * Generates an Observable that emits a sequence of integers within a + * Generates an Observable that emits a sequence of Integers within a * specified range. *

* @@ -1028,9 +1030,9 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T * {@link Subscription} is returned, it is 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 + * @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 RxJava Wiki: range() * @see Observable.Range Method (Int32, Int32) */ @@ -1039,14 +1041,15 @@ public static Observable range(int start, int count) { } /** - * Generates an Observable that emits a sequence of integers within a + * Generates an Observable that emits a sequence of Integers within a * specified range with the specified scheduler. *

* - * @param start the value of the first integer in the sequence - * @param count the number of sequential integers to generate + * + * @param start the value of the first Integer in the sequence + * @param count the number of sequential Integers to generate * @param scheduler the scheduler to run the generator loop on - * @return an Observable that emits a range of sequential integers + * @return an Observable that emits a range of sequential Integers * @see RxJava Wiki: range() * @see Observable.Range Method (Int32, Int32, IScheduler) */ @@ -1057,7 +1060,7 @@ public static Observable range(int start, int count, Scheduler schedule /** * 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. + * subscriber, the actual Observable is determined by the factory function. *

* *

@@ -1092,8 +1095,7 @@ public static Observable defer(Func0> o * 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 value the item to emit * @param the type of that item * @return an Observable that emits a single item and then completes * @see RxJava Wiki: just() @@ -1106,18 +1108,17 @@ public static Observable just(T value) { } /** - * Returns an Observable that emits a single item and then completes on a + * Returns an Observable that emits a single item and then completes, on a * specified scheduler. *

* *

* This is a scheduler version of {@link Observable#just(Object)}. * - * @param value the item to pass to the {@link Observer}'s - * {@link Observer#onNext onNext} method + * @param value the item to emit * @param the type of that item - * @param scheduler the scheduler to send the single element on - * @return an Observable that emits a single item and then completes on a + * @param scheduler the scheduler to emit the single item on + * @return an Observable that emits a single item and then completes, on a * specified scheduler * @see RxJava Wiki: just() */ @@ -1860,8 +1861,8 @@ public static Observable mergeDelayError(Observable t1, Obse * 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} + * @return an Observable that never emits any items or sends any + * notifications to an {@link Observer} * @see RxJava Wiki: never() */ public static Observable never() { @@ -1869,15 +1870,15 @@ public static Observable never() { } /** - * Given an Observable that emits Observables, creates a single Observable - * that emits the items emitted by the most recently published of those + * Given an Observable that emits Observables, returns an Observable that + * emits the items emitted by the most recently emitted 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 + * @return an Observable that emits only the items emitted by the Observable + * most recently emitted by the source Observable * @see RxJava Wiki: switchOnNext() * @deprecated use {@link #switchOnNext} */ @@ -1887,15 +1888,15 @@ public static Observable switchDo(Observable * * * @param sequenceOfSequences the source Observable that emits Observables - * @return an Observable that emits only the items emitted by the most - * recently published Observable + * @return an Observable that emits only the items emitted by the Observable + * most recently emitted by the source Observable * @see RxJava Wiki: switchOnNext() */ public static Observable switchOnNext(Observable> sequenceOfSequences) { @@ -1929,8 +1930,8 @@ public Observable synchronize() { /** * Accepts an Observable and wraps it in another Observable that ensures * that the resulting Observable is chronologically well-behaved. This is - * accomplished by acquiring a mutual-exclusion lock for the object - * provided as the lock parameter. + * accomplished by acquiring a mutual-exclusion lock for the object provided + * as the lock parameter. *

* *

@@ -1962,7 +1963,8 @@ public static Observable synchronize(Observable source) { } /** - * Emits an item each time interval (containing a sequential number). + * Returns an Observable that emits an item each time interval, containing + * a sequential number. *

* * @@ -1977,7 +1979,8 @@ public static Observable interval(long interval, TimeUnit unit) { } /** - * Emits an item each time interval (containing a sequential number). + * Returns an Observable that emits an item each time interval, containing + * a sequential number. *

* * @@ -1993,56 +1996,64 @@ public static Observable interval(long interval, TimeUnit unit, Scheduler } /** - * Emits one item after a given delay, and then completes. + * Returns an Observable that emits one item after a given delay, and then + * completes. + *

+ * * - * @param interval - * interval size in time units - * @param unit - * time units to use for the interval size + * @param interval interval size in time units + * @param unit time units to use for the interval size + * @see RxJava wiki: timer() */ public static Observable timer(long interval, TimeUnit unit) { return create(OperationTimer.timer(interval, unit)); } /** - * Emits one item after a given delay, and then completes. + * Returns an Observable that emits one item after a given delay, and then + * completes. + *

+ * * - * @param interval - * interval size in time units - * @param unit - * time units to use for the interval size - * @param scheduler - * the scheduler to use for scheduling the item + * @param interval interval size in time units + * @param unit time units to use for the interval size + * @param scheduler the scheduler to use for scheduling the item + * @see RxJava wiki: timer() */ public static Observable timer(long interval, TimeUnit unit, Scheduler scheduler) { return create(OperationTimer.timer(interval, unit, scheduler)); } /** - * Returns an Observable that emits the results of shifting the items emitted by the source - * Observable by a specified delay. Errors emitted by the source Observable are not delayed. - * @param delay - * the delay to shift the source by - * @param unit - * the {@link TimeUnit} in which period is defined + * Returns an Observable that emits the items emitted by the source + * Observable shifted forward in time by a specified delay. Error + * notifications from the source Observable are not delayed. + *

+ * + * + * @param delay the delay to shift the source by + * @param unit the {@link TimeUnit} in which period is defined * @return the source Observable, but shifted by the specified delay - * @see MSDN: Observable.Delay + * @see RxJava Wiki: delay() + * @see MSDN: Observable.Delay */ public Observable delay(long delay, TimeUnit unit) { return OperationDelay.delay(this, delay, unit, Schedulers.threadPoolForComputation()); } /** - * Returns an Observable that emits the results of shifting the items emitted by the source - * Observable by a specified delay. Errors emitted by the source Observable are not delayed. - * @param delay - * the delay to shift the source by - * @param unit - * the {@link TimeUnit} in which period is defined - * @param scheduler - * the {@link Scheduler} to use for delaying + * Returns an Observable that emits the items emitted by the source + * Observable shifted forward in time by a specified delay. Error + * notifications from the source Observable are not delayed. + *

+ * + * + * @param delay the delay to shift the source by + * @param unit the {@link TimeUnit} in which period is defined + * @param scheduler the {@link Scheduler} to use for delaying * @return the source Observable, but shifted by the specified delay - * @see MSDN: Observable.Delay + * @see RxJava Wiki: delay() + * @see MSDN: Observable.Delay */ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { return OperationDelay.delay(this, delay, unit, scheduler); @@ -2052,8 +2063,8 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. *

- * Note: If events keep firing faster than the timeout then no data will be - * emitted. + * Note: If events keep firing faster than the timeout then no items will be + * emitted by the resulting Observable. *

* *

@@ -2065,11 +2076,12 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { *

  • Javascript - don't spam your server: debounce and throttle
    • * * - * @param timeout the time each value has to be "the most recent" of the - * {@link Observable} to ensure that it's not dropped + * @param timeout the time each item has to be "the most recent" of those + * emitted by the source {@link Observable} to ensure that + * it's not dropped * @param unit the {@link TimeUnit} for the timeout - * @return an {@link Observable} that filters out items that are too - * quickly followed by newer items + * @return an {@link Observable} that filters out items that are too quickly + * followed by newer items * @see RxJava Wiki: debounce() * @see #throttleWithTimeout(long, TimeUnit) */ @@ -2081,8 +2093,8 @@ public Observable debounce(long timeout, TimeUnit unit) { * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. *

    - * Note: If events keep firing faster than the timeout then no data will be - * emitted. + * Note: If events keep firing faster than the timeout then no items will be + * emitted by the resulting Observable. *

    * *

    @@ -2094,13 +2106,14 @@ public Observable debounce(long timeout, TimeUnit unit) { *

  • Javascript - don't spam your server: debounce and throttle
    • * * - * @param timeout the time each value has to be "the most recent" of the - * {@link Observable} to ensure that it's not dropped + * @param timeout the time each item has to be "the most recent" of those + * emitted by the source {@link Observable} to ensure that + * it's not dropped * @param unit the unit of time for the specified timeout * @param scheduler the {@link Scheduler} to use internally to manage the * timers that handle the timeout for each event - * @return an {@link Observable} that filters out items that are too - * quickly followed by newer items + * @return an {@link Observable} that filters out items that are too quickly + * followed by newer items * @see RxJava Wiki: debounce() * @see #throttleWithTimeout(long, TimeUnit, Scheduler) */ @@ -2112,8 +2125,8 @@ public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. *

    - * Note: If events keep firing faster than the timeout then no data will be - * emitted. + * Note: If events keep firing faster than the timeout then no items will be + * emitted by the resulting Observable. *

    * *

    @@ -2125,11 +2138,12 @@ public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) *

  • Javascript - don't spam your server: debounce and throttle
    • * * - * @param timeout the time each value has to be "the most recent" of the - * {@link Observable} to ensure that it's not dropped + * @param timeout the time each item has to be "the most recent" of those + * emitted by the source {@link Observable} to ensure that + * it's not dropped * @param unit the {@link TimeUnit} for the timeout - * @return an {@link Observable} that filters out items that are too - * quickly followed by newer items + * @return an {@link Observable} that filters out items that are too quickly + * followed by newer items * @see RxJava Wiki: throttleWithTimeout() * @see #debounce(long, TimeUnit) */ @@ -2141,8 +2155,8 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit) { * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. *

    - * Note: If events keep firing faster than the timeout then no data will be - * emitted. + * Note: If events keep firing faster than the timeout then no items will be + * emitted by the resulting Observable. *

    * *

    @@ -2154,13 +2168,13 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit) { *

  • Javascript - don't spam your server: debounce and throttle
    • * * - * @param timeout the time each value has to be "the most recent" of the - * {@link Observable} to ensure that it's not dropped + * @param timeout the time each item has to be "the most recent" emitted by + * the {@link Observable} to ensure that it's not dropped * @param unit the {@link TimeUnit} for the timeout * @param scheduler the {@link Scheduler} to use internally to manage the - * timers that handle the timeout for each event - * @return an {@link Observable} that filters out items that are too - * quickly followed by newer items + * timers that handle the timeout for each item + * @return an {@link Observable} that filters out items that are too quickly + * followed by newer items * @see RxJava Wiki: throttleWithTimeout() * @see #debounce(long, TimeUnit, Scheduler) */ @@ -2169,15 +2183,16 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler } /** - * Throttles by skipping items until "skipDuration" passes and then emits - * the next received item. + * Throttles by skipping items emitted by the source Observable until + * windowDuration passes and then emitting the next item + * emitted by the source Observable. *

    * This differs from {@link #throttleLast} in that this only tracks passage * of time whereas {@link #throttleLast} ticks at scheduled intervals. *

    * * - * @param windowDuration time to wait before sending another item after + * @param windowDuration time to wait before emitting another item after * emitting the last item * @param unit the unit of time for the specified timeout * @return an Observable that performs the throttle operation @@ -2188,15 +2203,16 @@ public Observable throttleFirst(long windowDuration, TimeUnit unit) { } /** - * Throttles by skipping items until "skipDuration" passes and then emits - * the next received item. + * Throttles by skipping items emitted by the source Observable until + * skipDuration passes and then emitting the next item emitted + * by the source Observable. *

    * This differs from {@link #throttleLast} in that this only tracks passage * of time whereas {@link #throttleLast} ticks at scheduled intervals. *

    * * - * @param skipDuration time to wait before sending another item after + * @param skipDuration time to wait before emitting another item after * emitting the last item * @param unit the unit of time for the specified timeout * @param scheduler the {@link Scheduler} to use internally to manage the @@ -2209,8 +2225,8 @@ public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler s } /** - * Throttles by emitting the last item in each interval defined by - * intervalDuration. + * Throttles by emitting the last item from the source Observable that falls + * in each interval defined by intervalDuration. *

    * This differs from {@link #throttleFirst} in that this ticks along at a * scheduled interval whereas {@link #throttleFirst} does not tick, it just @@ -2219,7 +2235,7 @@ public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler s * * * @param intervalDuration duration of windows within which the last item - * will be emitted + * emitted by the source Observable will be emitted * @param unit the unit of time for the specified interval * @return an Observable that performs the throttle operation * @see RxJava Wiki: throttleLast() @@ -2240,7 +2256,7 @@ public Observable throttleLast(long intervalDuration, TimeUnit unit) { * * * @param intervalDuration duration of windows within which the last item - * will be emitted + * emitted by the source Observable will be emitted * @param unit the unit of time for the specified interval * @param scheduler the {@link Scheduler} to use internally to manage the * timers that handle timeout for each event @@ -2356,16 +2372,17 @@ public static Observable from(Future future, long timeout, T } /** - * Returns an Observable that emits a Boolean value that indicates - * whether two sequences are equal by comparing the elements pairwise. + * Returns an Observable that emits a Boolean value that indicates whether + * two sequences are equal by comparing the elements emitted by each + * Observable pairwise. *

    * * * @param first the first Observable to compare * @param second the second Observable to compare * @param the type of items emitted by each Observable - * @return an Observable that emits a Boolean value that indicates - * whether two sequences are equal by comparing the elements pairwise + * @return an Observable that emits a Boolean value that indicates whether + * two sequences are equal by comparing the elements pairwise * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second) { @@ -2381,9 +2398,10 @@ public Boolean call(T first, T second) { } /** - * Returns an Observable that emits a Boolean value that indicates - * whether two sequences are equal by comparing the elements pairwise - * based on the results of a specified equality function. + * Returns an Observable that emits a Boolean value that indicates whether + * two sequences are equal by comparing the elements emitted by each + * Observable pairwise based on the results of a specified equality + * function. *

    * * @@ -2392,8 +2410,8 @@ public Boolean call(T first, T second) { * @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 a Boolean value that indicates - * whether two sequences are equal by comparing the elements pairwise + * @return an Observable that emits a Boolean value that indicates whether + * two sequences are equal by comparing the elements pairwise * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second, Func2 equality) { @@ -2680,19 +2698,20 @@ public static Observable zip(Observab } /** - * 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. + * Combines the given Observables, emitting an item that aggregates the + * latest values of each of the source Observables each time an item is + * received from any of the source Observables, where this aggregation is + * defined by a 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 + * items emitted by the source Observables + * @return an Observable whose emissions are the result of combining the + * emissions of the source Observables with the given aggregation + * function * @see RxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) { @@ -2700,10 +2719,10 @@ public static Observable combineLatest(Observable o } /** - * 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. + * Combines the given Observables, emitting an item that aggregates the + * latest values of each of the source Observables each time an item is + * received from any of the source Observables, where this aggregation is + * defined by a given function. *

    * * @@ -2711,9 +2730,10 @@ public static Observable combineLatest(Observable o * @param o2 the second source Observable * @param o3 the third 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 + * items emitted by the source Observables + * @return an Observable whose emissions are the result of combining the + * emissions of the source Observables with the given aggregation + * function * @see RxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) { @@ -2721,10 +2741,10 @@ public static Observable combineLatest(Observable * * @@ -2733,9 +2753,10 @@ public static Observable combineLatest(ObservableRxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, @@ -2744,10 +2765,10 @@ public static Observable combineLatest(Observable * * @@ -2757,9 +2778,10 @@ public static Observable combineLatest(ObservableRxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, @@ -2768,10 +2790,10 @@ public static Observable combineLatest(Observable * * @@ -2782,9 +2804,10 @@ public static Observable combineLatest(ObservableRxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, @@ -2793,10 +2816,10 @@ public static Observable combineLatest(Observable } /** - * 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. + * Combines the given Observables, emitting an item that aggregates the + * latest values of each of the source Observables each time an item is + * received from any of the source Observables, where this aggregation is + * defined by a given function. *

    * * @@ -2808,9 +2831,10 @@ public static Observable combineLatest(Observable * @param o6 the sixth source Observable * @param o7 the seventh 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 + * items emitted by the source Observables + * @return an Observable whose emissions are the result of combining the + * emissions of the source Observables with the given aggregation + * function * @see RxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, @@ -2819,10 +2843,10 @@ public static Observable combineLatest(Observ } /** - * 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. + * Combines the given Observables, emitting an item that aggregates the + * latest values of each of the source Observables each time an item is + * received from any of the source Observables, where this aggregation is + * defined by a given function. *

    * * @@ -2835,9 +2859,10 @@ public static Observable combineLatest(Observ * @param o7 the seventh source Observable * @param o8 the eighth 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 + * items emitted by the source Observables + * @return an Observable whose emissions are the result of combining the + * emissions of the source Observables with the given aggregation + * function * @see RxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, @@ -2846,10 +2871,10 @@ public static Observable combineLatest(Ob } /** - * 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. + * Combines the given Observables, emitting an item that aggregates the + * latest values of each of the source Observables each time an item is + * received from any of the source Observables, where this aggregation is + * defined by a given function. *

    * * @@ -2863,9 +2888,10 @@ public static Observable combineLatest(Ob * @param o8 the eighth source Observable * @param o9 the ninth 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 + * items emitted by the source Observables + * @return an Observable whose emissions are the result of combining the + * emissions of the source Observables with the given aggregation + * function * @see RxJava Wiki: combineLatest() */ public static Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, @@ -2873,28 +2899,26 @@ public static Observable combineLates return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, o9, combineFunction)); } -/** - * Creates an Observable that produces buffers of collected items. + /** + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping buffers. It emits the current buffer and replaces it with + * a new buffer when the Observable produced by the specified + * bufferClosingSelector emits an item. It then uses the + * bufferClosingSelector to create a new Observable to observe + * for the end of the next buffer. *

    * - *

    - * 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 bufferClosingSelector produces an - * object. The bufferClosingSelector - * 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 an 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 an - * object + * created. When this {@link Observable} emits + * an item, buffer() emits the + * associated buffer and replaces it with a new + * one. + * @return an {@link Observable} that emits connected, non-overlapping + * buffers when the current {@link Observable} created with the + * {@code bufferClosingSelector} argument emits an item * @see RxJava Wiki: buffer() */ public Observable> buffer(Func0> bufferClosingSelector) { @@ -2902,28 +2926,22 @@ public Observable> buffer(Func0bufferOpenings Observable emits an item, + * and closes when the Observable returned from + * bufferClosingSelector emits an item. *

    * - *

    - * This Observable produces buffers. Buffers are created when the specified - * bufferOpenings Observable produces an - * object. Additionally the bufferClosingSelector argument is - * used to create an Observable which produces - * objects. When this Observable produces such an object, the associated - * buffer is emitted. * - * @param bufferOpenings the {@link Observable} that, when it produces an - * object, will cause another - * buffer to be created + * @param bufferOpenings the {@link Observable} that, when it emits an item, + * causes a new buffer to be created * @param bufferClosingSelector the {@link Func1} that is used to produce * an {@link Observable} for every buffer - * created. When this {@link Observable} - * produces an object, - * the associated buffer is emitted. - * @return an {@link Observable} that produces buffers that are created and - * emitted when the specified {@link Observable}s publish certain - * objects + * created. When this {@link Observable} emits + * an item, the associated buffer is emitted. + * @return an {@link Observable} that emits buffers that are created and + * closed when the specified {@link Observable}s emit items * @see RxJava Wiki: buffer() */ public Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) { @@ -2931,18 +2949,20 @@ public Observable> buffer(Observablecount items. When + * the source Observable completes or encounters an error, it emits the + * current buffer is emitted, and propagates the notification from the + * source Observable. *

    * - *

    - * This Observable produces connected, non-overlapping buffers, each - * containing count items. 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} that produces connected, non-overlapping - * buffers containing at most "count" items + * @param count the maximum number of items in each buffer before it should + * be emitted + * @return an {@link Observable} that emits connected, non-overlapping + * buffers, each containing at most "count" items from the source + * Observable * @see RxJava Wiki: buffer() */ public Observable> buffer(int count) { @@ -2950,23 +2970,22 @@ public Observable> buffer(int count) { } /** - * Creates an Observable which produces buffers of collected items. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits buffers every + * skip items, each containing count items. When + * the source Observable completes or encounters an error, the resulting + * Observable emits the current buffer and propagates the notification from + * the source Observable. *

    * - *

    - * This Observable produces buffers every skip items, each - * containing count items. 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 items need to be skipped before starting a * new buffer. Note that when skip and * count are equal, this is the same operation as * {@link Observable#buffer(int)}. - * @return an {@link Observable} that produces buffers every - * skip item containing at most count - * items + * @return an {@link Observable} that emits buffers every skip + * item and containing at most count items * @see RxJava Wiki: buffer() */ public Observable> buffer(int count, int skip) { @@ -2974,20 +2993,20 @@ public Observable> buffer(int count, int skip) { } /** - * Creates an Observable that produces buffers of collected values. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping buffers, each of a fixed duration specified by the + * timespan argument. When the source Observable completes or + * encounters an error, the resulting Observable emits the current buffer + * and propagates the notification from the source Observable. *

    * - *

    - * 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 collects values before it + * @param timespan the period of time each buffer collects items 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} that produces connected, non-overlapping + * @return an {@link Observable} that emits connected, non-overlapping * buffers with a fixed duration * @see RxJava Wiki: buffer() */ @@ -2996,22 +3015,22 @@ public Observable> buffer(long timespan, TimeUnit unit) { } /** - * Creates an Observable that produces buffers of collected values. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping buffers, each of a fixed duration specified by the + * timespan argument. When the source Observable completes or + * encounters an error, the resulting Observable emits the current buffer + * and propagates the notification from the source Observable. *

    * - *

    - * 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 collects values before it + * @param timespan the period of time each buffer collects items 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} that produces connected, non-overlapping + * @return an {@link Observable} that emits connected, non-overlapping * buffers with a fixed duration * @see RxJava Wiki: buffer() */ @@ -3020,23 +3039,26 @@ public Observable> buffer(long timespan, TimeUnit unit, Scheduler schedu } /** - * Creates an Observable that produces buffers of collected items. 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 (whichever is reached - * first). When the source Observable completes or encounters an error, the - * current buffer is emitted and the event is propagated. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping buffers, each of a fixed duration specified by the + * timespan argument or a maximum size specified by the + * count argument (whichever is reached first). When the source + * Observable completes or encounters an error, the resulting Observable + * emits the current buffer and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each buffer collects values before it + * @param timespan the period of time each buffer collects items 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} that produces connected, non-overlapping - * buffers that are emitted after a fixed duration or when the - * buffer reaches maximum capacity (whichever occurs first) + * @return an {@link Observable} that emits connected, non-overlapping + * buffers of items emitted from the source Observable, after a + * fixed duration or when the buffer reaches maximum capacity + * (whichever occurs first) * @see RxJava Wiki: buffer() */ public Observable> buffer(long timespan, TimeUnit unit, int count) { @@ -3044,25 +3066,28 @@ public Observable> buffer(long timespan, TimeUnit unit, int count) { } /** - * Creates an Observable that produces buffers of collected items. 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 (whichever is reached - * first). When the source Observable completes or encounters an error, the - * current buffer is emitted and the event is propagated. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping buffers, each of a fixed duration specified by the + * timespan argument or a maximum size specified by the + * count argument (whichever is reached first). When the source + * Observable completes or encounters an error, the resulting Observable + * emits the current buffer and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each buffer collects values before it + * @param timespan the period of time each buffer collects items 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} that produces connected, non-overlapping - * buffers that are emitted after a fixed duration or when the - * buffer has reached maximum capacity (whichever occurs first) + * @return an {@link Observable} that emits connected, non-overlapping + * buffers of items emitted by the source Observable after a fixed + * duration or when the buffer reaches maximum capacity (whichever + * occurs first) * @see RxJava Wiki: buffer() */ public Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) { @@ -3070,23 +3095,25 @@ public Observable> buffer(long timespan, TimeUnit unit, int count, Sched } /** - * Creates an Observable that produces buffers of collected items. This - * Observable starts a new buffer periodically, as 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. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable starts a new buffer + * periodically, as determined by the timeshift argument. It + * emits buffer after a fixed timespan, specified by the + * timespan argument. When the source Observable completes or + * encounters an error, it emits the current buffer and propagates the + * notification from the source Observable. *

    * * - * @param timespan the period of time each buffer collects values before it + * @param timespan the period of time each buffer collects items 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 that applies to the timespan * and timeshift arguments - * @return an {@link Observable} that produces new buffers periodically and - * emits these after a fixed timespan has elapsed. + * @return an {@link Observable} that emits new buffers of items emitted by + * the source Observable periodically after a fixed timespan has + * elapsed * @see RxJava Wiki: buffer() */ public Observable> buffer(long timespan, long timeshift, TimeUnit unit) { @@ -3094,16 +3121,17 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit) } /** - * Creates an Observable that produces buffers of collected items. This - * Observable starts a new buffer periodically, as 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. + * Creates an Observable that emits buffers of items it collects from the + * source Observable. The resulting Observable starts a new buffer + * periodically, as determined by the timeshift argument. It + * emits each buffer after a fixed timespan, specified by the + * timespan argument. When the source Observable completes or + * encounters an error, the resulting Observable emits the current buffer + * propagates the notification from the source Observable. *

    * * - * @param timespan the period of time each buffer collects values before it + * @param timespan the period of time each buffer collects items before it * should be emitted * @param timeshift the period of time after which a new buffer will be * created @@ -3111,8 +3139,9 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit) * and timeshift arguments * @param scheduler the {@link Scheduler} to use when determining the end * and start of a buffer - * @return an {@link Observable} that produces new buffers periodically and - * emits these after a fixed timespan has elapsed + * @return an {@link Observable} that emits new buffers of items emitted by + * the source Observable periodically after a fixed timespan has + * elapsed * @see RxJava Wiki: buffer() */ public Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { @@ -3120,24 +3149,23 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit, } /** - * Creates an Observable that produces windows of collected items. 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 closingSelector produces an - * object. The closingSelector will - * then be used to create a new Observable to listen for the end of the next - * window. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows. It emits the current window and opens a new one + * when the Observable produced by the specified + * closingSelector emits an item. The + * closingSelector then creates a new Observable to observe + * for the end of the next window. *

    * * * @param closingSelector the {@link Func0} used to produce an * {@link Observable} for every window created. When this - * {@link Observable} emits an object, the - * associated window is emitted and replaced with a new one. - * @return an {@link Observable} that produces connected, non-overlapping - * windows, which are emitted when the current {@link Observable} - * created with the closingSelector argument emits an - * object. + * {@link Observable} emits an item, window() emits + * the associated window and begins a new one. + * @return an {@link Observable} that emits connected, non-overlapping + * windows when the current {@link Observable} created with the + * closingSelector argument emits an item * @see RxJava Wiki: window() */ public Observable> window(Func0> closingSelector) { @@ -3145,26 +3173,23 @@ public Observable> window(Func0windowOpenings Observable produces an - * object. Additionally the closingSelector argument creates an - * Observable that produces objects. When this - * Observable produces such an object, the associated window is emitted. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits windows. These windows + * contain those items emitted by the source Observable between the time + * when the windowOpenings Observable emits an item and when + * the Observable returned by closingSelector emits an item. *

    * * - * @param windowOpenings the {@link Observable} that, when it produces an - * object, causes another - * window to be created - * @param closingSelector the {@link Func1} that produces an + * @param windowOpenings the {@link Observable} that, when it emits an item, + * causes another window to be created + * @param closingSelector a {@link Func1} that produces an * {@link Observable} for every window created. When - * this {@link Observable} produces an - * object, the associated - * window is emitted. - * @return an {@link Observable} that produces windows that are created and - * emitted when the specified {@link Observable}s publish certain - * objects + * this {@link Observable} emits an item, the + * associated window is closed and emitted + * @return an {@link Observable} that emits windows of items emitted by the + * source Observable that are governed by the specified + * {@link Observable}s emitting items * @see RxJava Wiki: window() */ public Observable> window(Observable windowOpenings, Func1> closingSelector) { @@ -3172,16 +3197,17 @@ public Observable> window(Observablecount elements. When the source Observable completes or - * encounters an error, the current window is emitted, and the event is - * propagated. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows, each containing count items. When + * the source Observable completes or encounters an error, the resulting + * Observable emits the current window and propagates the notification from + * the source Observable. *

    * * * @param count the maximum size of each window before it should be emitted - * @return an {@link Observable} that produces connected, non-overlapping + * @return an {@link Observable} that emits connected, non-overlapping * windows containing at most count items * @see RxJava Wiki: window() */ @@ -3190,11 +3216,12 @@ public Observable> window(int count) { } /** - * Creates an Observable that produces windows of collected items. This - * Observable produces windows every skip items, each - * containing count elements. When the source Observable - * completes or encounters an error, the current window is emitted and the - * event is propagated. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits windows every + * skip items, each containing count items. + * When the source Observable completes or encounters an error, the + * resulting Observable emits the current window and propagates the + * notification from the source Observable. *

    * * @@ -3202,7 +3229,7 @@ public Observable> window(int count) { * @param skip how many items need to be skipped before starting a new * window. Note that if skip and count * are equal this is the same operation as {@link #window(int)}. - * @return an {@link Observable} that produces windows every "skipped" + * @return an {@link Observable} that emits windows every "skipped" * items containing at most count items * @see RxJava Wiki: window() */ @@ -3211,11 +3238,12 @@ public Observable> window(int count, int skip) { } /** - * Creates an Observable that produces windows of collected items. 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. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows, each of a fixed duration specified by the + * timespan argument. When the source Observable completes or + * encounters an error, the resulting Observable emits the current window + * and propagates the notification from the source Observable. *

    * * @@ -3223,7 +3251,7 @@ public Observable> window(int count, int skip) { * should be emitted and replaced with a new window * @param unit the unit of time that applies to the timespan * argument - * @return an {@link Observable} that produces connected, non-overlapping + * @return an {@link Observable} that emits connected, non-overlapping * windows with a fixed duration * @see RxJava Wiki: window() */ @@ -3232,11 +3260,12 @@ public Observable> window(long timespan, TimeUnit unit) { } /** - * Creates an Observable that produces windows of collected items. This - * Observable produces connected, non-overlapping windows, each of a fixed - * duration as specified by the timespan argument. When the - * source Observable completes or encounters an error, the current window is - * emitted and the event is propagated. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows, each of a fixed duration as specified by the + * timespan argument. When the source Observable completes or + * encounters an error, the resulting Observable emits the current window + * and propagates the notification from the source Observable. *

    * * @@ -3246,7 +3275,7 @@ public Observable> window(long timespan, TimeUnit unit) { * argument * @param scheduler the {@link Scheduler} to use when determining the end * and start of a window - * @return an {@link Observable} that produces connected, non-overlapping + * @return an {@link Observable} that emits connected, non-overlapping * windows with a fixed duration * @see RxJava Wiki: window() */ @@ -3255,23 +3284,25 @@ public Observable> window(long timespan, TimeUnit unit, Scheduler } /** - * Creates an Observable that produces windows of collected items. This - * Observable produces connected non-overlapping windows, each of a fixed - * duration as specified by the timespan argument or a maximum - * size as specified by the count argument (whichever is - * reached first). When the source Observable completes or encounters an - * error, the current window is emitted and the event is propagated. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows, each of a fixed duration as specified by the + * timespan argument or a maximum size as specified by the + * count argument (whichever is reached first). When the source + * Observable completes or encounters an error, the resulting Observable + * emits the current window and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each window collects values before it + * @param timespan the period of time each window collects items before it * should be emitted and replaced with a new window * @param unit the unit of time that applies to the timespan * argument * @param count the maximum size of each window before it should be emitted - * @return an {@link Observable} that produces connected, non-overlapping - * windows that are emitted after a fixed duration or when the - * window has reached maximum capacity (whichever occurs first) + * @return an {@link Observable} that emits connected, non-overlapping + * windows after a fixed duration or when the window has reached + * maximum capacity (whichever occurs first) * @see RxJava Wiki: window() */ public Observable> window(long timespan, TimeUnit unit, int count) { @@ -3279,25 +3310,27 @@ public Observable> window(long timespan, TimeUnit unit, int count) } /** - * Creates an Observable that produces windows of collected items. 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 (whichever is reached - * first). When the source Observable completes or encounters an error, the - * current window is emitted and the event is propagated. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable emits connected, + * non-overlapping windows, each of a fixed duration specified by the + * timespan argument or a maximum size specified by the + * count argument (whichever is reached first). When the source + * Observable completes or encounters an error, the resulting Observable + * emits the current window and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each window collects values before it + * @param timespan the period of time each window collects items 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} that produces connected non-overlapping - * windows that are emitted after a fixed duration or when the - * window has reached maximum capacity (whichever occurs first). + * @return an {@link Observable} that emits connected non-overlapping + * windows after a fixed duration or when the window has reached + * maximum capacity (whichever occurs first). * @see RxJava Wiki: window() */ public Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) { @@ -3305,23 +3338,25 @@ public Observable> window(long timespan, TimeUnit unit, int count, } /** - * Creates an Observable that produces windows of collected items. This - * Observable starts a new window periodically, as 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. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable starts a new window + * periodically, as determined by the timeshift argument. It + * emits each window after a fixed timespan, specified by the + * timespan argument. When the source Observable completes or + * Observable completes or encounters an error, the resulting Observable + * emits the current window and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each window collects values before it + * @param timespan the period of time each window collects items 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 that applies to the timespan * and timeshift arguments - * @return an {@link Observable} that produces new windows periodically and - * emits these after a fixed timespan has elapsed + * @return an {@link Observable} that emits new windows periodically as a + * fixed timespan has elapsed * @see RxJava Wiki: window() */ public Observable> window(long timespan, long timeshift, TimeUnit unit) { @@ -3329,16 +3364,18 @@ public Observable> window(long timespan, long timeshift, TimeUnit } /** - * Creates an Observable that produces windows of collected items. This - * Observable starts a new window periodically, as 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. + * Creates an Observable that emits windows of items it collects from the + * source Observable. The resulting Observable starts a new window + * periodically, as determined by the timeshift argument. It + * emits each window after a fixed timespan, specified by the + * timespan argument. When the source Observable completes or + * Observable completes or encounters an error, the resulting Observable + * emits the current window and propagates the notification from the source + * Observable. *

    * * - * @param timespan the period of time each window collects values before it + * @param timespan the period of time each window collects items before it * should be emitted * @param timeshift the period of time after which a new window will be * created @@ -3346,8 +3383,8 @@ public Observable> window(long timespan, long timeshift, TimeUnit * and timeshift arguments * @param scheduler the {@link Scheduler} to use when determining the end * and start of a window - * @return an {@link Observable} that produces new windows periodically and - * emits these after a fixed timespan has elapsed + * @return an {@link Observable} that emits new windows periodically as a + * fixed timespan has elapsed * @see RxJava Wiki: window() */ public Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) { @@ -3425,7 +3462,7 @@ public static Observable zip(Iterable> ws, FuncN< * @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 + * @return an Observable that emits only those items emitted by the source * Observable that the filter evaluates as {@code true} * @see RxJava Wiki: filter() */ @@ -3434,12 +3471,13 @@ public Observable filter(Func1 predicate) { } /** - * Returns an Observable that forwards all sequentially distinct items - * emitted from the source Observable. + * Returns an Observable that emits all sequentially distinct items + * emitted by the source Observable. *

    * * - * @return an Observable of sequentially distinct items + * @return an Observable that emits those items from the source Observable + * that are sequentially distinct * @see RxJava Wiki: distinctUntilChanged() * @see MSDN: Observable.distinctUntilChanged */ @@ -3448,16 +3486,17 @@ public Observable distinctUntilChanged() { } /** - * Returns an Observable that forwards all items emitted from the source + * Returns an Observable that emits all items emitted by the source * Observable that are sequentially distinct according to a key selector * function. *

    * * * @param keySelector a function that projects an emitted item to a key - * value that is used for deciding whether an item is + * value that is used to decide whether an item is * sequentially distinct from another one or not - * @return an Observable of sequentially distinct items + * @return an Observable that emits those items from the source Observable + * whose keys are sequentially distinct * @see RxJava Wiki: distinctUntilChanged() * @see MSDN: Observable.distinctUntilChanged */ @@ -3466,12 +3505,13 @@ public Observable distinctUntilChanged(Func1 keyS } /** - * Returns an Observable that emits all distinct items emitted from the - * source Observable. + * Returns an Observable that emits all items emitted by the source + * Observable that are distinct. *

    * * - * @return an Observable of distinct items + * @return an Observable that emits only those items emitted by the source + * Observable that are distinct from each other * @see RxJava Wiki: distinct() * @see MSDN: Observable.distinct */ @@ -3480,7 +3520,7 @@ public Observable distinct() { } /** - * Returns an Observable that emits all items emitted from the source + * Returns an Observable that emits all items emitted by the source * Observable that are distinct according to a key selector function. *

    * @@ -3488,7 +3528,8 @@ public Observable distinct() { * @param keySelector a function that projects an emitted item to a key * value that is used to decide whether an item is * distinct from another one or not - * @return an Observable that emits distinct items + * @return an Observable that emits those items emitted by the source + * Observable that have distinct keys * @see RxJava Wiki: distinct() * @see MSDN: Observable.distinct */ @@ -3497,16 +3538,17 @@ public Observable distinct(Func1 keySelector) { } /** - * Returns the item at a specified index in a sequence. + * Returns an Observable that emits the item at a specified index in a + * sequence of emissions from a source Observbable. *

    * * * @param index the zero-based index of the item to retrieve * @return an Observable that emits the item at the specified position in - * the source sequence + * the sequence of those emitted by the source Observable * @throws IndexOutOfBoundsException if index is greater than - * or equal to the number of elements in - * the source sequence + * or equal to the number of items emitted + * by the source Observable * @throws IndexOutOfBoundsException if index is less than 0 * @see RxJava Wiki: elementAt() */ @@ -3533,33 +3575,37 @@ public Observable elementAtOrDefault(int index, T defaultValue) { } /** - * Returns an {@link Observable} that emits true if any element - * of the source {@link Observable} satisfies the given condition, otherwise - * false. Note: always emits false if the source - * {@link Observable} is empty. + * Returns an {@link Observable} that emits true if any item + * emitted by the source {@link Observable} satisfies a specified condition, + * otherwise false. Note: this always emits false + * if the source {@link Observable} is empty. *

    - * In Rx.Net this is the any operator but renamed in RxJava to - * better match Java naming idioms. + * In Rx.Net this is the any operator but we renamed it in + * RxJava to better match Java naming idioms. *

    * * - * @param predicate the condition to test every element + * @param predicate the condition to test every item emitted by the source + * Observable * @return a subscription function for creating the target Observable * @see RxJava Wiki: exists() - * @see MSDN: Observable.Any Note: the description in this page is wrong. + * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing. */ public Observable exists(Func1 predicate) { return create(OperationAny.exists(this, predicate)); } /** - * Determines whether an Observable sequence contains a specified item. + * Returns an Observable that emits a Boolean that indicates whether the + * source Observable emitted a specified item. *

    * * - * @param element the item to search in the sequence - * @return an Observable that emits true if the item is in the - * source sequence + * @param element the item to search for in the emissions from the source + * Observable + * @return an Observable that emits true if the specified item + * is emitted by the source Observable, or false if the + * source Observable completes without emitting that item * @see RxJava Wiki: contains() * @see MSDN: Observable.Contains */ @@ -3620,7 +3666,7 @@ public Observable flatMap(Func1RxJava Wiki: where() * @see #filter(Func1) @@ -3631,7 +3677,8 @@ public Observable where(Func1 predicate) { /** * Returns an Observable that applies the given function to each item - * emitted by an Observable and emits the result. + * emitted by an Observable and emits the results of these function + * applications. *

    * * @@ -3647,13 +3694,14 @@ public Observable map(Func1 func) { /** * Returns an Observable that applies the given function to each item - * emitted by an Observable and emits the result. + * emitted by an Observable and emits the results of these function + * applications. *

    * * - * @param func a function to apply to each item emitted by the Observable. - * The function takes the index of the emitted item as - * additional parameter. + * @param func a function to apply to each item emitted by the Observable + * that takes the index of the emitted item as additional + * parameter * @return an Observable that emits the items from the source Observable, * transformed by the given function * @see RxJava Wiki: mapWithIndex() @@ -3687,16 +3735,16 @@ public Observable mapMany(Func1 * * * @return an Observable whose items are the result of materializing the * items and notifications of the source Observable * @see RxJava Wiki: materialize() - * @see MSDN: Observable.materialize + * @see MSDN: Observable.materialize */ public Observable> materialize() { return create(OperationMaterialize.materialize(this)); @@ -3872,8 +3920,7 @@ public Observable onExceptionResumeNext(final Observable resumeS * 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. + * it will instead emit the return value of resumeFunction. *

    * You can use this to prevent errors from propagating or to supply fallback * data should errors be encountered. @@ -3908,7 +3955,7 @@ public Observable onErrorReturn(Func1 resumeFunction) * 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 - * @throws IllegalArgumentException if the Observable sequence is empty + * @throws IllegalArgumentException if the source Observable emits no items * @see RxJava Wiki: reduce() * @see MSDN: Observable.Aggregate * @see Wikipedia: Fold (higher-order function) @@ -3923,12 +3970,12 @@ public Observable reduce(Func2 accumulator) { } /** - * Returns an Observable that counts the total number of items in the - * source Observable. + * Returns an Observable emits the count of the total number of items + * emitted by the source Observable. *

    * * - * @return an Observable that emits the number of counted elements of the + * @return an Observable that emits the number of elements emitted by the * source Observable as its single item * @see RxJava Wiki: count() * @see MSDN: Observable.Count @@ -3944,14 +3991,14 @@ public Integer call(Integer t1, T t2) { } /** - * Returns an Observable that sums up the integers emitted by the source - * Observable. + * Returns an Observable that emits the sum of all the Integers emitted by + * the source Observable. *

    * * * @param source source Observable to compute the sum of - * @return an Observable that emits the sum of all the items of the - * source Observable as its single item + * @return an Observable that emits the sum of all the Integers emitted by + * the source Observable as its single item * @see RxJava Wiki: sum() * @see MSDN: Observable.Sum */ @@ -3960,13 +4007,13 @@ public static Observable sum(Observable source) { } /** - * Returns an Observable that sums up the longs emitted by the source - * Observable. + * Returns an Observable that emits the sum of all the Longs emitted by the + * source Observable. *

    * * * @param source source Observable to compute the sum of - * @return an Observable that emits the sum of all the items of the + * @return an Observable that emits the sum of all the Longs emitted by the * source Observable as its single item * @see RxJava Wiki: sumLongs() * @see MSDN: Observable.Sum @@ -3976,13 +4023,13 @@ public static Observable sumLongs(Observable source) { } /** - * Returns an Observable that sums up the floats emitted by the source - * Observable. + * Returns an Observable that emits the sum of all the Floats emitted by the + * source Observable. *

    * * * @param source source Observable to compute the sum of - * @return an Observable that emits the sum of all the items of the + * @return an Observable that emits the sum of all the Floats emitted by the * source Observable as its single item * @see RxJava Wiki: sumFloats() * @see MSDN: Observable.Sum @@ -3992,14 +4039,14 @@ public static Observable sumFloats(Observable source) { } /** - * Returns an Observable that sums up the doubles emitted by the source - * Observable. + * Returns an Observable that emits the sum of all the Doubles emitted by + * the source Observable. *

    * * * @param source source Observable to compute the sum of - * @return an Observable that emits the sum of all the items of the - * source Observable as its single item + * @return an Observable that emits the sum of all the Doubles emitted by + * the source Observable as its single item * @see RxJava Wiki: sumDoubles() * @see MSDN: Observable.Sum */ @@ -4008,15 +4055,15 @@ public static Observable sumDoubles(Observable source) { } /** - * Returns an Observable that computes the average of the integers emitted + * Returns an Observable that computes the average of the Integers emitted * by the source Observable. *

    * * * @param source source observable to compute the average of - * @return an Observable that emits the average of all the items emitted by - * the source Observable as its single item - * @throws IllegalArgumentException if the Observable sequence is empty + * @return an Observable that emits the average of all the Integers emitted + * by the source Observable as its single item + * @throws IllegalArgumentException if the source Observable emits no items * @see RxJava Wiki: average() * @see MSDN: Observable.Average */ @@ -4025,13 +4072,13 @@ public static Observable average(Observable source) { } /** - * Returns an Observable that computes the average of the longs emitted by + * Returns an Observable that computes the average of the Longs emitted by * the source Observable. *

    * * - * @param source source observable to compute the average of - * @return an Observable that emits the average of all the items emitted by + * @param source source Observable to compute the average of + * @return an Observable that emits the average of all the Longs emitted by * the source Observable as its single item * @see RxJava Wiki: averageLongs() * @see MSDN: Observable.Average @@ -4041,13 +4088,13 @@ public static Observable averageLongs(Observable source) { } /** - * Returns an Observable that computes the average of the floats emitted by + * Returns an Observable that computes the average of the Floats emitted by * the source Observable. *

    * * - * @param source source observable to compute the average of - * @return an Observable that emits the average of all the items emitted by + * @param source source Observable to compute the average of + * @return an Observable that emits the average of all the Floats emitted by * the source Observable as its single item * @see RxJava Wiki: averageFloats() * @see MSDN: Observable.Average @@ -4057,14 +4104,14 @@ public static Observable averageFloats(Observable source) { } /** - * Returns an Observable that computes the average of the doubles emitted + * Returns an Observable that emits the average of the Doubles emitted * by the source Observable. *

    * * - * @param source source observable to compute the average of - * @return an Observable that emits the average of all the items emitted by - * the source Observable as its single item + * @param source source Observable to compute the average of + * @return an Observable that emits the average of all the Doubles emitted + * by the source Observable as its single item * @see RxJava Wiki: averageDoubles() * @see MSDN: Observable.Average */ @@ -4073,13 +4120,15 @@ public static Observable averageDoubles(Observable source) { } /** - * Returns the minimum item emitted by an Observable. If there are more than - * one minimum items, its returns the last one. + * Returns an Observable that emits the minimum item emitted by the source + * Observable. If there is more than one such item, it returns the + * last-emitted one. *

    * * - * @param source an Observable sequence to determine the minimum item of - * @return an Observable that emits the minimum item + * @param source an Observable to determine the minimum item of + * @return an Observable that emits the minimum item emitted by the source + * Observable * @throws IllegalArgumentException if the source is empty * @see MSDN: Observable.Min */ @@ -4088,14 +4137,14 @@ public static > Observable min(Observable } /** - * Returns the minimum item emitted by an Observable according to a - * specified comparator. If there are more than one minimum items, it - * returns the last one. + * Returns an Observable that emits the minimum item emitted by the source + * Observable, according to a specified comparator. If there is more than + * one such item, it returns the last-emitted one. *

    * * * @param comparator the comparer used to compare elements - * @return an Observable that emits the minimum value according to the + * @return an Observable that emits the minimum item according to the * specified comparator * @throws IllegalArgumentException if the source is empty * @see RxJava Wiki: min() @@ -4106,15 +4155,15 @@ public Observable min(Comparator comparator) { } /** - * Returns the items emitted by an Observable sequence with the minimum key - * value. For an empty source, returns an Observable that emits an empty - * List. + * Returns an Observable that emits a List of items emitted by the source + * Observable that have the minimum key value. For a source Observable that + * emits no items, the resulting Observable emits an empty List. *

    * * * @param selector the key selector function - * @return an Observable that emits a List of the items with the minimum key - * value + * @return an Observable that emits a List of the items from the source + * Observable that had the minimum key value * @see RxJava Wiki: minBy() * @see MSDN: Observable.MinBy */ @@ -4123,16 +4172,18 @@ public > Observable> minBy(Func1 s } /** - * Returns the elements emitted by an Observable with the minimum key value - * according to the specified comparator. For an empty source, it returns an - * Observable that emits an empty List. + * Returns an Observable that emits a List of items emitted by the source + * Observable that have the minimum key value according to a given + * comparator function. For a source Observable that emits no items, the + * resulting Observable emits an empty List. *

    * * * @param selector the key selector function * @param comparator the comparator used to compare key values - * @return an Observable that emits a List of the elements with the minimum - * key value according to the specified comparator + * @return an Observable that emits a List of the items emitted by the + * source Observable that had the minimum key value according to the + * specified comparator * @see RxJava Wiki: minBy() * @see MSDN: Observable.MinBy */ @@ -4141,13 +4192,14 @@ public Observable> minBy(Func1 selector, Comparator } /** - * Returns the maximum item emitted by an Observable. If there is more - * than one maximum item, it returns the last one. + * Returns an Observable that emits the maximum item emitted by the source + * Observable. If there is more than one item with the same maximum value, + * it emits the last-emitted of these. *

    * * - * @param source an Observable to determine the maximum item of - * @return an Observable that emits the maximum element + * @param source an Observable to scan for the maximum emitted item + * @return an Observable that emits this maximum item from the source * @throws IllegalArgumentException if the source is empty * @see RxJava Wiki: max() * @see MSDN: Observable.Max @@ -4157,15 +4209,15 @@ public static > Observable max(Observable } /** - * Returns the maximum item emitted by an Observable according to the - * specified comparator. If there is more than one maximum item, it returns - * the last one. + * Returns an Observable that emits the maximum item emitted by the source + * Observable, according to the specified comparator. If there is more than + * one item with the same maximum value, it emits the last-emitted of these. *

    * * * @param comparator the comparer used to compare items - * @return an Observable that emits the maximum item according to the - * specified comparator + * @return an Observable that emits the maximum item emitted by the source + * Observable, according to the specified comparator * @throws IllegalArgumentException if the source is empty * @see RxJava Wiki: max() * @see MSDN: Observable.Max @@ -4175,14 +4227,15 @@ public Observable max(Comparator comparator) { } /** - * Returns the items emitted by an Observable with the maximum key value. - * For an empty source, it returns an Observable that emits an empty List. + * Returns an Observable that emits a List of items emitted by the source + * Observable that have the maximum key value. For a source Observable that + * emits no items, the resulting Observable emits an empty List. *

    * * * @param selector the key selector function - * @return an Observable that emits a List of the items with the maximum key - * value + * @return an Observable that emits a List of those items emitted by the + * source Observable that had the maximum key value * @see RxJava Wiki: maxBy() * @see MSDN: Observable.MaxBy */ @@ -4191,16 +4244,18 @@ public > Observable> maxBy(Func1 s } /** - * Returns the items emitted by an Observable with the maximum key value - * according to the specified comparator. For an empty source, it returns an - * Observable that emits an empty List. + * Returns an Observable that emits a List of items emitted by the source + * Observable that have the maximum key value according to a specified + * comparator. For a source Observable that emits no items, the resulting + * Observable emits an empty List. *

    * * * @param selector the key selector function * @param comparator the comparator used to compare key values - * @return an Observable that emits a List of the elements with the maximum - * key value according to the specified comparator + * @return an Observable that emits a List of those items emitted by the + * source Observable that had the maximum key value according to the + * specified comparator * @see RxJava Wiki: maxBy() * @see MSDN: Observable.MaxBy */ @@ -4224,22 +4279,24 @@ public ConnectableObservable replay() { } /** - * Retry subscription to origin Observable upto given retry count. + * Retry subscription to the source Observable when it calls + * onError up to a certain number of retries. *

    * *

    - * 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. + * If the source Observable calls {@link Observer#onError}, this method will + * resubscribe to the source Observable for a maximum of + * retryCount resubscriptions. *

    - * For example, if an Observable fails on first time but emits [1, 2] then + * Any and all items emitted by the source Observable will be emitted by + * the resulting Observable, even those emitted during failed subscriptions. + * For example, if an Observable fails at first 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]. + * sequence of emissions and notifications would be + * [1, 2, 1, 2, 3, 4, 5, onCompleted]. * * @param retryCount number of retry attempts before failing - * @return an Observable with retry logic + * @return the source Observable modified with retry logic * @see RxJava Wiki: retry() */ public Observable retry(int retryCount) { @@ -4247,22 +4304,22 @@ public Observable retry(int retryCount) { } /** - * Retry subscription to origin Observable whenever onError is - * called (infinite retry count). + * Retry subscription to the source Observable whenever it calls + * onError (infinite retry count). *

    * *

    - * If {@link Observer#onError} is invoked the source Observable will be - * re-subscribed to. + * If the source Observable calls {@link Observer#onError}, this method will + * resubscribe to the source Observable. *

    - * 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 + * Any and all items emitted by the source Observable will be emitted by + * the resulting Observable, even those emitted during failed subscriptions. + * For example, if an Observable fails at first 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]. + * sequence of emissions and notifications would be + * [1, 2, 1, 2, 3, 4, 5, onCompleted]. * - * @return an Observable with retry logic + * @return the source Observable modified with retry logic * @see RxJava Wiki: retry() */ public Observable retry() { @@ -4290,7 +4347,7 @@ public Observable retry() { * 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. + * items and notifications for the benefit of subsequent observers * @see RxJava Wiki: cache() */ public Observable cache() { @@ -4333,7 +4390,6 @@ public Observable parallel(final Func1, Observable> f, f return OperationParallel.parallel(this, f, s); } - /** * Merges an Observable<Observable<T>> to * Observable<Observable<T>> with the number of @@ -4351,7 +4407,7 @@ public Observable parallel(final Func1, Observable> f, f * * * @param parallelObservables the number of Observables to merge into - * @return an Observable of Observables constrained to number defined by + * @return an Observable of Observables constrained in number by * parallelObservables * @see RxJava Wiki: parallelMerge() */ @@ -4377,9 +4433,9 @@ public static Observable> parallelMerge(Observable * * @param parallelObservables the number of Observables to merge into - * @param scheduler - * @return an Observable of Observables constrained to number defined by - * parallelObservables. + * @param scheduler the Scheduler to run each Observable on + * @return an Observable of Observables constrained in number by + * parallelObservables * @see RxJava Wiki: parallelMerge() */ public static Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) { @@ -4403,8 +4459,8 @@ public ConnectableObservable publish() { } /** - * Returns a {@link ConnectableObservable} that shares a single subscription - * that contains the last notification only. + * Returns a {@link ConnectableObservable} that emits only the last item + * emitted by the source Observable. *

    * * @@ -4479,9 +4535,6 @@ public Observable aggregate(R initialValue, Func2 accumu * *

    * 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 @@ -4531,16 +4584,16 @@ public Observable sample(long period, TimeUnit unit, Scheduler scheduler) { } /** - * Return an Observable that emits the results of sampling the items - * emitted by this Observable when the sampler - * Observable produces an item or completes. + * Return an Observable that emits the results of sampling the items emitted + * by this Observable when the sampler Observable emits an item + * or completes. *

    * * - * @param sampler the Observable to use for sampling this + * @param sampler the Observable to use for sampling the source Observable * @return an Observable that emits the results of sampling the items - * emitted by this Observable when the sampler - * Observable produces an item or completes. + * emitted by this Observable whenever the sampler + * Observable emits an item or completes * @see RxJava Wiki: sample() */ public Observable sample(Observable sampler) { @@ -4561,7 +4614,7 @@ public Observable sample(Observable sampler) { * 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 initialValue the initial (seed) accumulator 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 @@ -4597,15 +4650,11 @@ public Observable all(Func1 predicate) { * 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 + * source Observable emits * @see RxJava Wiki: skip() */ public Observable skip(int num) { @@ -4618,9 +4667,9 @@ public Observable skip(int num) { *

    * * - * @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 + * @return an Observable that emits only the very first item emitted by the + * source Observable, or nothing if the source Observable completes + * without emitting a single item * @see RxJava Wiki: first() * @see MSDN: Observable.First */ @@ -4636,8 +4685,8 @@ public Observable first() { * * @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 + * given condition from the source, or nothing if the source + * Observable completes without emitting a single matching item * @see RxJava Wiki: first() * @see MSDN: Observable.First */ @@ -4647,14 +4696,14 @@ public Observable first(Func1 predicate) { /** * Returns an Observable that emits only the very first item emitted by the - * source Observable, or a default value. + * source Observable, or a default item. *

    * * - * @param defaultValue the default value to emit if the source Observable + * @param defaultValue the default item 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 + * source, or a default item if the source Observable completes * without emitting a single item * @see RxJava Wiki: firstOrDefault() * @see MSDN: Observable.FirstOrDefault @@ -4665,16 +4714,16 @@ public Observable firstOrDefault(T 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 + * source Observable that satisfies a given condition, or a default item * otherwise. *

    * * * @param predicate the condition any source emitted item has to satisfy - * @param defaultValue the default value to emit if the source Observable + * @param defaultValue the default item 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 + * that satisfies the given condition, or a default item otherwise * @see RxJava Wiki: firstOrDefault() * @see MSDN: Observable.FirstOrDefault */ @@ -4683,14 +4732,16 @@ public Observable firstOrDefault(Func1 predicate, T defau } /** - * Returns the elements of the specified sequence or the specified default - * value in a singleton sequence if the sequence is empty. + * Returns an Observable that emits the items emitted by the source + * Observable or a specified default item if the source Observable is empty. *

    * * - * @param defaultValue the value to return if the sequence is empty - * @return an Observable that emits the specified default value if the - * source is empty; otherwise, the items emitted by the source + * @param defaultValue the item to emit if the source Observable emits no + * items + * @return an Observable that emits either the specified default item if the + * source Observable emits no items, or the items emitted by the + * source Observable * @see RxJava Wiki: defaultIfEmpty() * @see MSDN: Observable.DefaultIfEmpty */ @@ -4711,9 +4762,9 @@ public Observable defaultIfEmpty(T defaultValue) { * * @param num the number of items to emit * @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 + * emitted by the source Observable, or all of the items from the + * source Observable if that Observable emits fewer than + * num items * @see RxJava Wiki: take() */ public Observable take(final int num) { @@ -4740,7 +4791,8 @@ public Observable takeWhile(final Func1 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. + * operate on both the item and its index relative to the complete sequence + * of items. *

    * * @@ -4847,7 +4899,7 @@ public Observable skipWhileWithIndex(Func2 predi /** * Returns an Observable that bypasses all items from the source Observable - * as long as the specified condition holds true, but emits all further + * as long as a specified condition holds true, but emits all further * source items as soon as the condition becomes false. *

    * @@ -4867,17 +4919,16 @@ public Observable skipWhile(Func1 predicate) { * Bypasses a specified number of items at the end of an Observable * sequence. *

    - * This operator accumulates a queue with a length enough to store the first + * This operator accumulates a queue long enough to store the first * count items. As more items are received, items are taken - * from the front of the queue and produced on the result sequence. This - * causes elements to be delayed. + * from the front of the queue and emitted by the returned Observable. This + * causes such items to be delayed. *

    * * - * @param count number of elements to bypass at the end of the source - * sequence - * @return an Observable sequence emitting the source sequence items - * except for the bypassed ones at the end + * @param count number of items to bypass at the end of the source sequence + * @return an Observable that emits the items emitted by the source + * Observable except for the bypassed ones at the end * @throws IndexOutOfBoundsException if count is less than zero * @see RxJava Wiki: skipLast() * @see MSDN: Observable.SkipLast @@ -5201,20 +5252,24 @@ public Observable> groupBy(final Func1 * * - * @param right the other Observable to correlate values of this observable to - * @param leftDuration function that returns an Observable which indicates the duration of - * the values of this Observable - * @param rightDuration function that returns an Observable which indicates the duration of - * the values of the right Observable - * @param resultSelector function that takes a left value, the right observable and returns the - * value to be emitted - * @return an Observable that emits grouped values based on overlapping durations from this and - * another Observable - * + * @param right the other Observable to correlate items from this Observable + * with + * @param leftDuration function that returns an Observable whose emissions + * indicate the duration of the values of this + * Observable + * @param rightDuration function that returns an Observable whose emissions + * indicate the duration of the values of the + * right Observable + * @param resultSelector function that takes an item emitted by each source + * Observable and returns the value to be emitted by + * the resulting Observable + * @return an Observable that emits grouped items based on overlapping + * durations from this and another Observable * @see RxJava Wiiki: groupJoin * @see MSDN: Observable.GroupJoin */ @@ -5225,11 +5280,11 @@ public Observable groupJoin(Observable right, Func1true if the source - * {@link Observable} is empty, otherwise false. + * Returns an Observable that emits true if the source + * Observable is empty, otherwise false. *

    - * In Rx.Net this is negated as the any operator but renamed in - * RxJava to better match Java naming idioms. + * In Rx.Net this is negated as the any operator but we renamed + * this in RxJava to better match Java naming idioms. *

    * * @@ -5242,27 +5297,28 @@ public Observable isEmpty() { } /** - * Returns an {@link Observable} that emits the last item emitted by the - * source or an IllegalArgumentException if the source - * {@link Observable} is empty. + * Returns an Observable that emits the last item emitted by the source or + * notifies observers of an IllegalArgumentException if the + * source Observable is empty. *

    * * - * @return + * @return an Observable that emits the last item from the source Observable + * or notifies observers of an error * @see RxJava Wiki: last() */ public Observable last() { return create(OperationLast.last(this)); } -/** - * Returns an Observable that counts the total number of items in the - * source Observable as a 64 bit long. + /** + * Returns an Observable that counts the total number of items emitted by + * the source Observable and emits this count as a 64-bit long. *

    * * - * @return an Observable that emits the number of counted elements of the - * source Observable as its single, 64 bit long item + * @return an Observable that emits the number of items emitted by the + * source Observable as its single, 64-bit long item * @see RxJava Wiki: count() * @see MSDN: Observable.LongCount * @see #count() @@ -5280,7 +5336,7 @@ public Long call(Long t1, T t2) { * Converts an Observable into a {@link BlockingObservable} (an Observable * with blocking operators). * - * @return + * @return a BlockingObservable version of this Observable * @see RxJava Wiki: Blocking Observable Operators */ public BlockingObservable toBlockingObservable() { @@ -5338,18 +5394,18 @@ public Observable ignoreElements() { } /** - * Applies a timeout policy for each element in the observable sequence, - * using the specified scheduler to run timeout timers. If the next element - * isn't received within the specified timeout duration starting from its - * predecessor, a TimeoutException is propagated to the observer. + * Applies a timeout policy for each item emitted by the Observable, using + * the specified scheduler to run timeout timers. If the next item isn't + * observed within the specified timeout duration starting from its + * predecessor, observers are notified of a TimeoutException. *

    * * - * @param timeout maximum duration between values before a timeout occurs + * @param timeout maximum duration between items before a timeout occurs * @param timeUnit the unit of time which applies to the * timeout argument. - * @return the source Observable with a TimeoutException in - * case of a timeout + * @return the source Observable modified to notify observers of a + * TimeoutException in case of a timeout * @see RxJava Wiki: timeout() * @see MSDN: Observable.Timeout */ @@ -5358,20 +5414,20 @@ public Observable timeout(long timeout, TimeUnit timeUnit) { } /** - * Applies a timeout policy for each element in the observable sequence, - * using the specified scheduler to run timeout timers. If the next element - * isn't received within the specified timeout duration starting from its - * predecessor, the other observable sequence is used to produce future - * messages from that point on. + * Applies a timeout policy for each item emitted by the Observable, using + * the specified scheduler to run timeout timers. If the next item isn't + * observed within the specified timeout duration starting from its + * predecessor, a specified fallback Observable produces future items and + * notifications from that point on. *

    * * - * @param timeout maximum duration between values before a timeout occurs + * @param timeout maximum duration between items before a timeout occurs * @param timeUnit the unit of time which applies to the * timeout argument - * @param other sequence to return in case of a timeout - * @return the source sequence switching to the other sequence in case of a - * timeout + * @param other fallback Observable to use in case of a timeout + * @return the source Observable modified to switch to the fallback + * Observable in case of a timeout * @see RxJava Wiki: timeout() * @see MSDN: Observable.Timeout */ @@ -5380,19 +5436,19 @@ public Observable timeout(long timeout, TimeUnit timeUnit, ObservableTimeoutException. *

    * * - * @param timeout maximum duration between values before a timeout occurs + * @param timeout maximum duration between items before a timeout occurs * @param timeUnit the unit of time which applies to the * timeout argument * @param scheduler Scheduler to run the timeout timers on - * @return the source sequence with a TimeoutException in case - * of a timeout + * @return the source Observable modified to notify observers of a + * TimeoutException in case of a timeout * @see RxJava Wiki: timeout() * @see MSDN: Observable.Timeout */ @@ -5401,21 +5457,21 @@ public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler schedule } /** - * Applies a timeout policy for each element in the observable sequence, - * using the specified scheduler to run timeout timers. If the next element - * isn't received within the specified timeout duration starting from its - * predecessor, the other observable sequence is used to produce future - * messages from that point on. + * Applies a timeout policy for each item emitted by the Observable, using + * the specified scheduler to run timeout timers. If the next item isn't + * observed within the specified timeout duration starting from its + * predecessor, a specified fallback Observable sequence produces future + * items and notifications from that point on. *

    * * - * @param timeout maximum duration between values before a timeout occurs + * @param timeout maximum duration between items before a timeout occurs * @param timeUnit the unit of time which applies to the * timeout argument - * @param other sequence to return in case of a timeout + * @param other Observable to use as the fallback in case of a timeout * @param scheduler Scheduler to run the timeout timers on - * @return the source sequence switching to the other sequence in case of a - * timeout + * @return the source Observable modified so that it will switch to the + * fallback Observable in case of a timeout * @see RxJava Wiki: timeout() * @see MSDN: Observable.Timeout */ @@ -5453,7 +5509,7 @@ public Observable> timeInterval(Scheduler scheduler) { } /** - * Constructs an Observable that depends on a resource object. + * Constructs an Observable that creates a dependent resource object. *

    * * @@ -5470,7 +5526,7 @@ public static Observable using(Func0 * * @@ -5486,7 +5542,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5503,7 +5559,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5521,7 +5577,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5540,7 +5596,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5560,7 +5616,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5581,7 +5637,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5603,7 +5659,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5626,7 +5682,7 @@ public static Observable amb(Observable o1, Observable * * @@ -5645,9 +5701,9 @@ public static Observable amb(Iterable> *

    * * - * @param observer the action to invoke for each item emitted in the source - * sequence - * @return the source sequence with the side-effecting behavior applied + * @param observer the action to invoke for each item emitted by the source + * Observable + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnEach() * @see MSDN: Observable.Do */ @@ -5660,9 +5716,9 @@ public Observable doOnEach(Observer observer) { *

    * * - * @param onNext the action to invoke for each item in the source - * sequence - * @return the source sequence with the side-effecting behavior applied + * @param onNext the action to invoke for each item emitted by the source + * Observable + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnEach() * @see MSDN: Observable.Do */ @@ -5686,12 +5742,13 @@ public void onNext(T args) { } /** - * Invokes an action if onError is called from the Observable. + * Invokes an action if the source Observable calls onError. *

    * * - * @param onError the action to invoke if onError is invoked - * @return the source sequence with the side-effecting behavior applied + * @param onError the action to invoke if the source Observable calls + * onError + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnError() * @see MSDN: Observable.Do */ @@ -5715,14 +5772,14 @@ public void onNext(T args) { } } /** - * Invokes an action when onCompleted is called by the - * Observable. + * Invokes an action when the source Observable calls + * onCompleted. *

    * * - * @param onCompleted the action to invoke when onCompleted is - * called - * @return the source sequence with the side-effecting behavior applied + * @param onCompleted the action to invoke when the source Observable calls + * onCompleted + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnCompleted() * @see MSDN: Observable.Do */ @@ -5750,10 +5807,11 @@ public void onNext(T args) { } *

    * * - * @param onNext the action to invoke for each item in the source sequence + * @param onNext the action to invoke for each item emitted by the + * Observable * @param onError the action to invoke when the source Observable calls * onError - * @return the source sequence with the side-effecting behavior applied + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnEach() * @see MSDN: Observable.Do */ @@ -5783,12 +5841,13 @@ public void onNext(T args) { *

    * * - * @param onNext the action to invoke for each item in the source sequence + * @param onNext the action to invoke for each item emitted by the + * Observable * @param onError the action to invoke when the source Observable calls * onError * @param onCompleted the action to invoke when the source Observable calls * onCompleted - * @return the source sequence with the side-effecting behavior applied + * @return the source Observable with the side-effecting behavior applied * @see RxJava Wiki: doOnEach() * @see MSDN: Observable.Do */ @@ -5853,14 +5912,12 @@ private boolean isInternalImplementation(Object o) { } /** - * Creates a pattern that matches when both Observable sequences have an - * available item. + * Creates a pattern that matches when both Observables emit an item. *

    * * - * @param right Observable sequence to match with the left sequence - * @return Pattern object that matches when both Observable sequences have - * an available item + * @param second Observable to match with the source Observable + * @return Pattern object that matches when both Observables emit an item * @throws NullPointerException if right is null * @see RxJava Wiki: and() * @see MSDN: Observable.And @@ -5870,15 +5927,15 @@ public Pattern2 and(Observable right) { } /** - * Matches when the Observable sequence has an available item and - * projects the item by invoking the selector function. + * Matches when the Observable has an available item and projects the item + * by invoking the selector function. *

    * * - * @param selector Selector that will be invoked for elements in the source - * sequence - * @return Plan that produces the projected results, to be fed (with other - * plans) to the When operator + * @param selector selector that will be invoked for items emitted by the + * source Observable + * @return a Plan that produces the projected results, to be fed (with other + * Plans) to the {@link #when} operator * @throws NullPointerException if selector is null * @see RxJava Wiki: then() * @see MSDN: Observable.Then @@ -5892,9 +5949,9 @@ public Plan0 then(Func1 selector) { *

    * * - * @param plans a series of plans created by use of the Then operator on - * patterns - * @return an Observable sequence with the results from matching several + * @param plans a series of plans created by use of the {@link #then} + * operator on patterns + * @return an Observable that emits the results from matching several * patterns * @throws NullPointerException if plans is null * @see RxJava Wiki: when() @@ -5909,9 +5966,9 @@ public static Observable when(Plan0... plans) { *

    * * - * @param plans a series of plans created by use of the Then operator on - * patterns - * @return an Observable sequence with the results from matching several + * @param plans a series of plans created by use of the {@link #then} + * operator on patterns + * @return an Observable that emits the results from matching several * patterns * @throws NullPointerException if plans is null * @see RxJava Wiki: when() @@ -5930,7 +5987,7 @@ public static Observable when(Iterable> plans) { * * * @param p1 the plan to join - * @return an Observable sequence with the results from matching a pattern + * @return an Observable that emits the results from matching a pattern * @see RxJava Wiki: when() * @see MSDN: Observable.When */ @@ -5946,7 +6003,7 @@ public static Observable when(Plan0 p1) { * * @param p1 a plan * @param p2 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -5964,7 +6021,7 @@ public static Observable when(Plan0 p1, Plan0 p2) { * @param p1 a plan * @param p2 a plan * @param p3 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -5983,7 +6040,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3) { * @param p2 a plan * @param p3 a plan * @param p4 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6003,7 +6060,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan * @param p3 a plan * @param p4 a plan * @param p5 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6024,7 +6081,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan * @param p4 a plan * @param p5 a plan * @param p6 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6046,7 +6103,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan * @param p5 a plan * @param p6 a plan * @param p7 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6069,7 +6126,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan * @param p6 a plan * @param p7 a plan * @param p8 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6093,7 +6150,7 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan * @param p7 a plan * @param p8 a plan * @param p9 a plan - * @return an Observable sequence with the results from matching several + * @return an Observable that emits the results from matching several * patterns * @see RxJava Wiki: when() * @see MSDN: Observable.When @@ -6104,22 +6161,22 @@ public static Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan } /** - * Correlates the elements of two sequences based on overlapping durations. + * Correlates the items emitted by two Observables based on overlapping + * durations. *

    * * - * @param right the right observable sequence to join elements for + * @param right the second Observable to join items from * @param leftDurationSelector a function to select the duration of each - * element of this observable sequence, used to + * item emitted by this Observable, used to * determine overlap * @param rightDurationSelector a function to select the duration of each - * element of the right observable sequence, - * used to determine overlap - * @param resultSelector a function invoked to compute a result element - * for any two overlapping elements of the left and - * right observable sequences - * @return an observable sequence that contains result elements computed - * from source elements that have an overlapping duration + * item emitted by the right + * Observable, used to determine overlap + * @param resultSelector a function that computes a result item for any two + * overlapping items emitted by the two Observables + * @return an Observable that emits result items computed from source items + * that have an overlapping duration * @see RxJava Wiki: join() * @see MSDN: Observable.Join */ @@ -6135,14 +6192,14 @@ public Observable join(Observable< * {@code keySelector} function. *

    * - * + *

    * If a source item maps to the same key, the HashMap will contain the * latest of those items. * * @param keySelector the function that extracts the key from the source * items to be used as keys in the HashMap * @return an Observable that emits a single HashMap containing the mapped - * values of the source Observable + * items from the source Observable * @see RxJava Wiki: toMap() * @see MSDN: Observable.ToDictionary */ @@ -6152,7 +6209,7 @@ public Observable> toMap(Func1 keySelector /** * Return an Observable that emits a single HashMap containing elements with - * key and value extracted from the values emitted by the source Observable. + * key and value extracted from the items emitted by the source Observable. *

    * *

    @@ -6164,7 +6221,7 @@ public Observable> toMap(Func1 keySelector * @param valueSelector the function that extracts the value from the source * items to be used as value in the HashMap * @return an Observable that emits a single HashMap containing the mapped - * values of the source Observable + * items from the source Observable * @see RxJava Wiki: toMap() * @see MSDN: Observable.ToDictionary */ @@ -6175,7 +6232,7 @@ public Observable> toMap(Func1 keySelec /** * Return an Observable that emits a single Map, returned by the * mapFactory function, containing key and value extracted from - * the values emitted by the source Observable. + * the items emitted by the source Observable. *

    * * @@ -6185,7 +6242,7 @@ public Observable> toMap(Func1 keySelec * items to be used as value in the Map * @param mapFactory the function that returns an Map instance to be used * @return an Observable that emits a single Map containing the mapped - * values of the source Observable + * items emitted by the source Observable * @see RxJava Wiki: toMap() */ public Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) { @@ -6194,7 +6251,7 @@ public Observable> toMap(Func1 keySelec /** * Return an Observable that emits a single HashMap containing an ArrayList - * of elements, emitted by the source Observable and keyed by the + * of items, emitted by the source Observable and keyed by the * keySelector function. *

    * @@ -6202,7 +6259,7 @@ public Observable> toMap(Func1 keySelec * @param keySelector the function that extracts the key from the source * items to be used as key in the HashMap * @return an Observable that emits a single HashMap containing an ArrayList - * of elements mapped from the source Observable + * of items mapped from the source Observable * @see RxJava Wiki: toMultiMap() * @see MSDN: Observable.ToLookup */ @@ -6223,7 +6280,7 @@ public Observable>> toMultimap(Func1RxJava Wiki: toMultiMap() * @see MSDN: Observable.ToLookup */ @@ -6245,7 +6302,7 @@ public Observable>> toMultimap(Func1RxJava Wiki: toMultiMap() */ public Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) { @@ -6254,7 +6311,7 @@ public Observable>> toMultimap(Func1mapFactory function, containing a custom collection of + * mapFactory function, that contains a custom collection of * values, extracted by the valueSelector function, emitted by * the source Observable and keyed by the keySelector function. *

    @@ -6268,7 +6325,7 @@ public Observable>> toMultimap(Func1RxJava Wiki: toMultiMap() */ public Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) { @@ -6276,15 +6333,15 @@ public Observable>> toMultimap(Func1 * * - * @param other the other Observable that has to emit an element before this + * @param other the other Observable that has to emit an item before this * Observable's elements are relayed - * @return an Observable that skips elements from the source Observable - * until the secondary Observable emits an element. + * @return an Observable that skips items from the source Observable + * until the secondary Observable emits an item. * @see RxJava Wiki: skipUntil() * @see MSDN: Observable.SkipUntil */ @@ -6300,9 +6357,9 @@ public Observable skipUntil(Observable other) { * * @param keySelector a function to extract the key for each item * @param durationSelector a function to signal the expiration of a group - * @return a sequence of Observable groups, each of which corresponds to a - * unique key value, containing all items that share that same - * key value + * @return an Observable that emits grouped Observables, each of which + * corresponds to a key value and emits all items that share that + * same key value that were emitted during the key's duration * @see RxJava Wiki: groupByUntil() * @see MSDN: Observable.GroupByUntil */ @@ -6318,12 +6375,12 @@ public Observable> groupByUntil(Fun * * * @param keySelector a function to extract the key for each item - * @param valueSelector a function to map each source element to an item + * @param valueSelector a function to map each source item to an item * emitted by an Observable group * @param durationSelector a function to signal the expiration of a group - * @return a sequence of Observable groups, each of which corresponds to a - * unique key value, containing all items that share that same key - * value + * @return an Observable that emits grouped Observables, each of which + * corresponds to a key value and emits all items that share that + * same key value that were emitted during the key's duration * @see RxJava Wiki: groupByUntil() * @see MSDN: Observable.GroupByUntil */ @@ -6332,35 +6389,41 @@ public Observable> gro } /** - * Invokes the specified function asynchronously, surfacing the result through an observable sequence. + * Invokes the specified function asynchronously and returns an Observable + * that emits the result. *

    - * Note: The function is called immediately, not during the subscription of the resulting - * sequence. Multiple subscriptions to the resulting sequence can observe the - * function's result. + * Note: The function is called immediately and once, not whenever an + * observer subscribes to the resulting Observable. Multiple subscriptions + * to this Observable observe the same return value. + *

    + * * - * @param func - * Function to run asynchronously. - * @return An observable sequence exposing the function's result value, or an exception. - * @see MSDN: Observable.Start + * @param func function to run asynchronously + * @return an Observable that emits the function's result value, or notifies + * observers of an exception + * @see RxJava Wiki: start() + * @see MSDN: Observable.Start */ public static Observable start(Func0 func) { return Async.toAsync(func).call(); } /** - * Invokes the specified function asynchronously on the specified scheduler, surfacing - * the result through an observable sequence. + * Invokes the specified function asynchronously on the specified scheduler + * and returns an Observable that emits the result. + *

    + * Note: The function is called immediately and once, not whenever an + * observer subscribes to the resulting Observable. Multiple subscriptions + * to this Observable observe the same return value. *

    - * Note: The function is called immediately, not during the subscription of the resulting - * sequence. Multiple subscriptions to the resulting sequence can observe the - * function's result. + * * - * @param func - * Function to run asynchronously. - * @param scheduler - * Scheduler to run the function on. - * @return An observable sequence exposing the function's result value, or an exception. - * @see MSDN: Observable.Start + * @param func function to run asynchronously + * @param scheduler scheduler to run the function on + * @return an Observable that emits the function's result value, or notifies + * observers of an exception + * @see RxJava Wiki: start() + * @see MSDN: Observable.Start */ public static Observable start(Func0 func, Scheduler scheduler) { return Async.toAsync(func, scheduler).call(); From 2bb345ba0eec283d2991aacd640df3976b26c872 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Thu, 12 Dec 2013 08:43:10 +0100 Subject: [PATCH 081/441] Operation Timer 3.0 --- rxjava-core/src/main/java/rx/Observable.java | 43 ++++++- .../java/rx/operators/OperationDelay.java | 5 +- .../java/rx/operators/OperationTimer.java | 116 ++++++++++-------- .../java/rx/operators/OperationTimerTest.java | 72 +++++++++++ 4 files changed, 176 insertions(+), 60 deletions(-) create mode 100644 rxjava-core/src/test/java/rx/operators/OperationTimerTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 7d870b3788..891e7fafaa 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -2001,12 +2001,12 @@ public static Observable interval(long interval, TimeUnit unit, Scheduler *

    * * - * @param interval interval size in time units + * @param delay the initial delay before emitting a single 0L * @param unit time units to use for the interval size * @see RxJava wiki: timer() */ - public static Observable timer(long interval, TimeUnit unit) { - return create(OperationTimer.timer(interval, unit)); + public static Observable timer(long delay, TimeUnit unit) { + return timer(delay, unit, Schedulers.threadPoolForComputation()); } /** @@ -2015,13 +2015,44 @@ public static Observable timer(long interval, TimeUnit unit) { *

    * * - * @param interval interval size in time units + * @param delay the initial delay before emitting a single 0L * @param unit time units to use for the interval size * @param scheduler the scheduler to use for scheduling the item * @see RxJava wiki: timer() */ - public static Observable timer(long interval, TimeUnit unit, Scheduler scheduler) { - return create(OperationTimer.timer(interval, unit, scheduler)); + public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) { + return create(new OperationTimer.TimerOnce(delay, unit, scheduler)); + } + + /** + * Return an Observable which emits a 0L after the initialDelay and ever increasing + * numbers after each period. + * + * @param initialDelay the initial delay time to wait before emitting the first value of 0L + * @param period the time period after emitting the subsequent numbers + * @param unit the time unit for both initialDelay and period + * @return an Observable which emits a 0L after the initialDelay and ever increasing + * numbers after each period + * @see MSDN: Observable.Timer + */ + public static Observable timer(long initialDelay, long period, TimeUnit unit) { + return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Return an Observable which emits a 0L after the initialDelay and ever increasing + * numbers after each period while running on the given scheduler. + * + * @param initialDelay the initial delay time to wait before emitting the first value of 0L + * @param period the time period after emitting the subsequent numbers + * @param unit the time unit for both initialDelay and period + * @param scheduler the scheduler where the waiting happens and value emissions run. + * @return an Observable which emits a 0L after the initialDelay and ever increasing + * numbers after each period while running on the given scheduler + * @see MSDN: Observable.Timer + */ + public static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { + return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler)); } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java index 9cf44ae5fb..b1f7b088da 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java +++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java @@ -28,8 +28,9 @@ public static Observable delay(Observable observable, final long delay // observable.map(x => Observable.timer(t).map(_ => x).startItAlreadyNow()).concat() Observable> seqs = observable.map(new Func1>() { public Observable call(final T x) { - ConnectableObservable co = Observable.timer(delay, unit, scheduler).map(new Func1() { - public T call(Void ignored) { + ConnectableObservable co = Observable.timer(delay, unit, scheduler).map(new Func1() { + @Override + public T call(Long ignored) { return x; } }).replay(); diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java index c8f9f3b33c..34a82e8eab 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java +++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java @@ -1,74 +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. - */ + /** + * 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 java.util.concurrent.TimeUnit; - import rx.Observable.OnSubscribeFunc; import rx.Observer; import rx.Scheduler; import rx.Subscription; -import rx.schedulers.Schedulers; -import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; +/** + * Operation Timer with several overloads. + * + * @see MSDN Observable.Timer + */ public final class OperationTimer { - - public static OnSubscribeFunc timer(long interval, TimeUnit unit) { - return timer(interval, unit, Schedulers.threadPoolForComputation()); - } - - public static OnSubscribeFunc timer(final long delay, final TimeUnit unit, final Scheduler scheduler) { - return new OnSubscribeFunc() { - @Override - public Subscription onSubscribe(Observer observer) { - return new Timer(delay, unit, scheduler, observer).start(); - } - }; - } - - private static class Timer { - private final long period; - private final TimeUnit unit; + private OperationTimer() { throw new IllegalStateException("No instances!"); } + + /** + * Emit a single 0L after the specified time elapses. + */ + public static class TimerOnce implements OnSubscribeFunc { private final Scheduler scheduler; - private final Observer observer; - - private Timer(long period, TimeUnit unit, Scheduler scheduler, Observer observer) { - this.period = period; - this.unit = unit; + private final long dueTime; + private final TimeUnit dueUnit; + public TimerOnce(long dueTime, TimeUnit unit, Scheduler scheduler) { this.scheduler = scheduler; - this.observer = observer; + this.dueTime = dueTime; + this.dueUnit = unit; } - - public Subscription start() { - final Subscription s = scheduler.schedule(new Action0() { + + @Override + public Subscription onSubscribe(final Observer t1) { + return scheduler.schedule(new Action0() { @Override public void call() { - observer.onNext(null); - observer.onCompleted(); + t1.onNext(0L); + t1.onCompleted(); } - }, period, unit); - - return Subscriptions.create(new Action0() { + + }, dueTime, dueUnit); + } + } + /** + * Emit 0L after the initial period and ever increasing number after each period. + */ + public static class TimerPeriodically implements OnSubscribeFunc { + private final Scheduler scheduler; + private final long initialDelay; + private final long period; + private final TimeUnit unit; + public TimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { + this.scheduler = scheduler; + this.initialDelay = initialDelay; + this.period = period; + this.unit = unit; + } + + @Override + public Subscription onSubscribe(final Observer t1) { + return scheduler.schedulePeriodically(new Action0() { + long count; @Override public void call() { - s.unsubscribe(); + t1.onNext(count++); } - }); + }, + initialDelay, period, unit + ); } } - } diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java new file mode 100644 index 0000000000..26521c7265 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java @@ -0,0 +1,72 @@ +/** + * 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 java.util.concurrent.TimeUnit; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mock; +import static org.mockito.Mockito.*; +import org.mockito.MockitoAnnotations; +import rx.Observable; +import rx.Observer; +import rx.Subscription; +import rx.schedulers.TestScheduler; + +public class OperationTimerTest { + @Mock + Observer observer; + TestScheduler s; + @Before + public void before() { + MockitoAnnotations.initMocks(this); + s = new TestScheduler(); + } + @Test + public void testTimerOnce() { + Observable.timer(100, TimeUnit.MILLISECONDS, s).subscribe(observer); + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + verify(observer, times(1)).onNext(0L); + verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } + @Test + public void testTimerPeriodically() { + Subscription c = Observable.timer(100, 100, TimeUnit.MILLISECONDS, s).subscribe(observer); + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(0L); + + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(1L); + + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(2L); + + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + inOrder.verify(observer, times(1)).onNext(3L); + + c.unsubscribe(); + s.advanceTimeBy(100, TimeUnit.MILLISECONDS); + inOrder.verify(observer, never()).onNext(any()); + + verify(observer, never()).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + } +} \ No newline at end of file From dcbcf8a2c56045d11c851d3ab70268cc1a851a2e Mon Sep 17 00:00:00 2001 From: akarnokd Date: Thu, 12 Dec 2013 13:02:39 +0100 Subject: [PATCH 082/441] CustomReplaySubject to support various replay() operators. --- rxjava-core/src/main/java/rx/Observable.java | 13 + .../java/rx/operators/OperationReplay.java | 739 ++++++++++++++++++ .../rx/operators/OperationReplayTest.java | 73 ++ 3 files changed, 825 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationReplay.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationReplayTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 7d870b3788..74a50c075f 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -4278,6 +4278,19 @@ public ConnectableObservable replay() { return OperationMulticast.multicast(this, ReplaySubject. create()); } + /** + * 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} on the given scheduler + * + * @param scheduler + * @return + * + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(Scheduler scheduler) { + return OperationMulticast.multicast(this, ReplaySubject. create()); + } /** * Retry subscription to the source Observable when it calls * onError up to a certain number of retries. diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java new file mode 100644 index 0000000000..8f9e332c16 --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java @@ -0,0 +1,739 @@ + /** + * 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 java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import rx.Observable; +import rx.Observable.OnSubscribeFunc; +import rx.Observer; +import rx.Scheduler; +import rx.Subscription; +import rx.subjects.Subject; +import rx.subscriptions.Subscriptions; +import rx.util.Timestamped; +import rx.util.functions.Action0; +import rx.util.functions.Func1; +import rx.util.functions.Functions; + +/** + * Replay with limited buffer and/or time constraints. + * + * + * @see MSDN: Observable.Replay overloads + */ +public final class OperationReplay { + /** Utility class. */ + private OperationReplay() { throw new IllegalStateException("No instances!"); } + + /** + * Create a BoundedReplaySubject with the given buffer size. + */ + public static Subject replayWithBufferSize(int bufferSize) { + return CustomReplaySubject.create(bufferSize); + } + /** + * Creates a subject whose client observers will observe events + * propagated through the given wrapped subject. + */ + public static Subject createScheduledSubject(Subject subject, Scheduler scheduler) { + Observable observedOn = subject.observeOn(scheduler); + SubjectWrapper s = new SubjectWrapper(subscriberOf(observedOn), subject); + return s; + } + /** + * Return an OnSubscribeFunc which delegates the subscription to the given observable. + */ + public static OnSubscribeFunc subscriberOf(final Observable target) { + return new OnSubscribeFunc() { + @Override + public Subscription onSubscribe(Observer t1) { + return target.subscribe(t1); + } + }; + } + + /** + * Create a CustomReplaySubject with the given time window length + * and optional buffer size. + * + * @param time the length of the time window + * @param unit the unit of the time window length + * @param bufferSize the buffer size if >= 0, otherwise, the buffer will be unlimited + * @param scheduler the scheduler from where the current time is retrieved. The + * observers will not observe on this scheduler. + * @return a Subject with the required replay behavior + */ + public static Subject replayWithTimeWindowOrBufferSize(long time, TimeUnit unit, int bufferSize, final Scheduler scheduler) { + final long ms = unit.toMillis(time); + if (ms <= 0) { + throw new IllegalArgumentException("The time window is less than 1 millisecond!"); + } + Func1> timestamp = new Func1>() { + @Override + public Timestamped call(T t1) { + return new Timestamped(scheduler.now(), t1); + } + }; + Func1, T> untimestamp = new Func1, T>() { + @Override + public T call(Timestamped t1) { + return t1.getValue(); + } + }; + + ReplayState, T> state; + + if (bufferSize >= 0) { + state = new ReplayState, T>(new VirtualBoundedList>(bufferSize), untimestamp); + } else { + state = new ReplayState, T>(new VirtualArrayList>(), untimestamp); + } + final ReplayState, T> fstate = state; + // time based eviction when a value is added + state.onValueAdded = new Action0() { + @Override + public void call() { + long now = scheduler.now(); + long before = now - ms; + for (int i = fstate.values.start(); i < fstate.values.end(); i++) { + Timestamped v = fstate.values.get(i); + if (v.getTimestampMillis() >= before) { + fstate.values.removeBefore(i); + break; + } + } + } + }; + // time based eviction when a client subscribes + state.onSubscription = state.onValueAdded; + + final CustomReplaySubject, T> brs = new CustomReplaySubject, T>( + new CustomReplaySubjectSubscribeFunc, T>(state), state, timestamp + ); + + return brs; + } + /** + * Subject that wraps another subject and uses a mapping function + * to transform the received values. + */ + public static final class MappingSubject extends Subject { + private final Subject subject; + private final Func1 selector; + public MappingSubject(OnSubscribeFunc func, Subject subject, Func1 selector) { + super(func); + this.subject = subject; + this.selector = selector; + } + + @Override + public void onNext(T args) { + subject.onNext(selector.call(args)); + } + + @Override + public void onError(Throwable e) { + subject.onError(e); + } + + @Override + public void onCompleted() { + subject.onCompleted(); + } + + } + + /** + * A subject that wraps another subject. + */ + public static final class SubjectWrapper extends Subject { + /** The wrapped subject. */ + final Subject subject; + public SubjectWrapper(OnSubscribeFunc func, Subject subject) { + super(func); + this.subject = subject; + } + + @Override + public void onNext(T args) { + subject.onNext(args); + } + + @Override + public void onError(Throwable e) { + subject.onError(e); + } + + @Override + public void onCompleted() { + subject.onCompleted(); + } + + } + + /** Base state with lock. */ + static class BaseState { + /** The lock to protect the other fields. */ + private final Lock lock = new ReentrantLock(); + /** Lock. */ + public void lock() { + lock.lock(); + } + /** Unlock. */ + public void unlock() { + lock.unlock(); + } + + } + /** + * Base interface for logically indexing a list. + * @param + */ + public interface VirtualList { + /** @return the number of elements in this list */ + int size(); + /** Add an element to the list. */ + void add(T value); + /** + * Retrieve an element at the specified logical index. + * @param index + * @return + */ + T get(int index); + /** + * Remove elements up before the given logical index and move + * the start() to this index. + *

    + * For example, a list contains 3 items. Calling removeUntil 2 will + * remove the first two items. + * @param index + */ + void removeBefore(int index); + /** + * Clear the elements of this list and increase the + * start by the number of elements. + */ + void clear(); + /** + * Returns the current head index of this list. + * @return + */ + int start(); + /** + * Returns the current tail index of this list (where the next value would appear). + * @return + */ + int end(); + /** + * Clears and resets the indexes of the list. + */ + void reset(); + } + /** + * Behaves like a normal, unbounded ArrayList but with virtual index. + */ + public static final class VirtualArrayList implements VirtualList { + /** The backing list .*/ + final List list = new ArrayList(); + /** The virtual start index of the list. */ + int startIndex; + @Override + public int size() { + return list.size(); + } + @Override + public void add(T value) { + list.add(value); + } + + @Override + public T get(int index) { + return list.get(index - startIndex); + } + + @Override + public void removeBefore(int index) { + int j = index - startIndex; + if (j > 0 && j <= list.size()) { + list.subList(0, j).clear(); + } + startIndex = index; + } + + @Override + public void clear() { + startIndex += list.size(); + list.clear(); + } + + @Override + public int start() { + return startIndex; + } + + @Override + public int end() { + return startIndex + list.size(); + } + + @Override + public void reset() { + list.clear(); + startIndex = 0; + } + + } + /** + * A bounded list which increases its size up to a maximum capacity, then + * behaves like a circular buffer with virtual indexes. + */ + public static final class VirtualBoundedList implements VirtualList { + /** A list that grows up to maxSize. */ + private final List list = new ArrayList(); + /** The maximum allowed size. */ + private final int maxSize; + /** The logical start index of the list. */ + int startIndex; + /** The head index inside the list, where the first readable value sits. */ + int head; + /** The tail index inside the list, where the next value will be added. */ + int tail; + /** The number of items in the list. */ + int count; + /** + * Construct a VirtualBoundedList with the given maximum number of elements. + * @param maxSize + */ + public VirtualBoundedList(int maxSize) { + if (maxSize < 0) { + throw new IllegalArgumentException("maxSize < 0"); + } + this.maxSize = maxSize; + } + @Override + public int start() { + return startIndex; + } + + @Override + public int end() { + return startIndex + count; + } + + @Override + public void clear() { + startIndex += count; + list.clear(); + head = 0; + tail = 0; + count = 0; + } + @Override + public int size() { + return count; + } + + @Override + public void add(T value) { + if (list.size() == maxSize) { + list.set(tail, value); + head = (head + 1) % maxSize; + tail = (tail + 1) % maxSize; + startIndex++; + } else { + list.add(value); + tail = (tail + 1) % maxSize; + count++; + } + } + + @Override + public T get(int index) { + if (index < start() || index >= end()) { + throw new ArrayIndexOutOfBoundsException(index); + } + int idx = (head + (index - startIndex)) % maxSize; + return list.get(idx); + } + + @Override + public void removeBefore(int index) { + if (index <= start()) { + return; + } + if (index >= end()) { + clear(); + startIndex = index; + return; + } + int rc = index - startIndex; + int head2 = head + rc; + for (int i = head; i < head2; i++) { + list.set(i % maxSize, null); + count--; + } + startIndex = index; + head = head2 % maxSize; + } + /** + * Returns a list with the current elements in this bounded list. + * @return + */ + public List toList() { + List r = new ArrayList(list.size() + 1); + for (int i = head; i < head + count; i++) { + int idx = i % maxSize; + r.add(list.get(idx)); + } + return r; + } + + @Override + public void reset() { + list.clear(); + count = 0; + head = 0; + tail = 0; + } + + } + /** + * The state class. + * @param the intermediate type stored in the values buffer + * @param the result type transformed via the resultSelector + */ + static final class ReplayState extends BaseState { + /** The values observed so far. */ + final VirtualList values; + /** The result selector. */ + final Func1 resultSelector; + /** The received error. */ + Throwable error; + /** General completion indicator. */ + boolean done; + /** The map of replayers. */ + final Map replayers = new LinkedHashMap(); + /** + * Callback once a value has been added but before it is replayed + * (I.e, run a time based eviction policy). + *

    + * Called while holding the state lock. + */ + protected Action0 onValueAdded = new Action0() { + @Override + public void call() { + } + }; + /** + * Callback once an error has been called but before it is replayed + * (I.e, run a time based eviction policy). + *

    + * Called while holding the state lock. + */ + protected Action0 onErrorAdded = new Action0() { + @Override + public void call() { + } + }; + /** + * Callback once completed has been called but before it is replayed + * (I.e, run a time based eviction policy). + *

    + * Called while holding the state lock. + */ + protected Action0 onCompletedAdded = new Action0() { + @Override + public void call() { + } + }; + /** + * Callback to pre-manage the values if an observer unsubscribes + * (I.e, run a time based eviction policy). + *

    + * Called while holding the state lock. + */ + protected Action0 onSubscription = new Action0() { + @Override + public void call() { + } + }; + /** + * Construct a ReplayState with the supplied buffer and result selectors. + * @param values + * @param resultSelector + */ + public ReplayState(final VirtualList values, + final Func1 resultSelector) { + this.values = values; + this.resultSelector = resultSelector; + } + /** + * Returns a live collection of the observers. + *

    + * Caller should hold the lock. + * @return + */ + Collection replayers() { + return new ArrayList(replayers.values()); + } + /** + * Add a replayer to the replayers and create a Subscription for it. + *

    + * Caller should hold the lock. + * + * @param obs + * @return + */ + Subscription addReplayer(Observer obs) { + Subscription s = new Subscription() { + final AtomicBoolean once = new AtomicBoolean(); + @Override + public void unsubscribe() { + if (once.compareAndSet(false, true)) { + remove(this); + } + } + + }; + Replayer rp = new Replayer(obs, s); + replayers.put(s, rp); + rp.replayTill(values.start() + values.size()); + return s; + } + /** The replayer that holds a value where the given observer is currently at. */ + final class Replayer { + protected final Observer wrapped; + /** Where this replayer was in reading the list. */ + protected int index; + /** To cancel and unsubscribe this replayer and observer. */ + protected final Subscription cancel; + protected Replayer(Observer wrapped, Subscription cancel) { + this.wrapped = wrapped; + this.cancel = cancel; + } + /** + * Replay up to the given index + * @param limit + */ + void replayTill(int limit) { + int si = values.start(); + if (index < si) { + index = si; + } + while (index < limit) { + TIntermediate value = values.get(index); + index++; + try { + wrapped.onNext(resultSelector.call(value)); + } catch (Throwable t) { + replayers.remove(cancel); + wrapped.onError(t); + return; + } + } + if (done) { + if (error != null) { + wrapped.onError(error); + } else { + wrapped.onCompleted(); + } + } + } + } + /** + * Remove the subscription. + * @param s + */ + void remove(Subscription s) { + lock(); + try { + replayers.remove(s); + } finally { + unlock(); + } + } + /** + * Add a notification value and limit the size of values. + *

    + * Caller should hold the lock. + * @param value + */ + void add(TIntermediate value) { + values.add(value); + } + /** Clears the value list. */ + void clearValues() { + lock(); + try { + values.clear(); + } finally { + unlock(); + } + } + } + /** + * A customizable replay subject with support for transformations. + * + * @param the Observer side's value type + * @param the type of the elements in the replay buffer + * @param the value type of the observers subscribing to this subject + */ + public static final class CustomReplaySubject extends Subject { + /** + * Return a subject that retains all events and will replay them to an {@link Observer} that subscribes. + * @return a subject that retains all events and will replay them to an {@link Observer} that subscribes. + */ + public static CustomReplaySubject create() { + ReplayState state = new ReplayState(new VirtualArrayList(), Functions.identity()); + return new CustomReplaySubject( + new CustomReplaySubjectSubscribeFunc(state), state, + Functions.identity()); + } + /** + * Create a bounded replay subject with the given maximum buffer size. + * @param maxSize the maximum size in number of onNext notifications + * @return + */ + public static CustomReplaySubject create(int maxSize) { + ReplayState state = new ReplayState(new VirtualBoundedList(maxSize), Functions.identity()); + return new CustomReplaySubject( + new CustomReplaySubjectSubscribeFunc(state), state, + Functions.identity()); + } + /** The replay state. */ + protected final ReplayState state; + /** The result selector. */ + protected final Func1 intermediateSelector; + + private CustomReplaySubject( + Observable.OnSubscribeFunc onSubscribe, + ReplayState state, + Func1 intermediateSelector) { + super(onSubscribe); + this.state = state; + this.intermediateSelector = intermediateSelector; + } + + + @Override + public void onCompleted() { + state.lock(); + try { + if (state.done) { + return; + } + state.done = true; + state.onCompletedAdded.call(); + replayValues(); + } finally { + state.unlock(); + } + } + + @Override + public void onError(Throwable e) { + state.lock(); + try { + if (state.done) { + return; + } + state.done = true; + state.error = e; + state.onErrorAdded.call(); + replayValues(); + } finally { + state.unlock(); + } + } + + @Override + public void onNext(TInput args) { + state.lock(); + try { + if (state.done) { + return; + } + state.add(intermediateSelector.call(args)); + state.onValueAdded.call(); + replayValues(); + } finally { + state.unlock(); + } + } + /** + * Replay values up to the current index. + */ + protected void replayValues() { + int s = state.values.start() + state.values.size(); + for (ReplayState.Replayer rp : state.replayers()) { + rp.replayTill(s); + } + } + } + /** + * The subscription function. + * @param the type of the elements in the replay buffer + * @param the value type of the observers subscribing to this subject + */ + protected static final class CustomReplaySubjectSubscribeFunc + implements Observable.OnSubscribeFunc { + + private final ReplayState state; + protected CustomReplaySubjectSubscribeFunc(ReplayState state) { + this.state = state; + } + + @Override + public Subscription onSubscribe(Observer t1) { + VirtualList values; + Throwable error; + state.lock(); + try { + if (!state.done) { + state.onSubscription.call(); + return state.addReplayer(t1); + } + values = state.values; + error = state.error; + } finally { + state.unlock(); + } + // fully replay the subject + for (int i = values.start(); i < values.end(); i++) { + try { + t1.onNext(state.resultSelector.call(values.get(i))); + } catch (Throwable t) { + t1.onError(t); + return Subscriptions.empty(); + } + } + if (error != null) { + t1.onError(error); + } else { + t1.onCompleted(); + } + return Subscriptions.empty(); + } + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java new file mode 100644 index 0000000000..6db879582c --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java @@ -0,0 +1,73 @@ +/** + * 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 java.util.Arrays; +import org.junit.Assert; +import org.junit.Test; +import rx.operators.OperationReplay.VirtualBoundedList; + +public class OperationReplayTest { + @Test + public void testBoundedList() { + VirtualBoundedList list = new VirtualBoundedList(3); + + list.add(1); // idx: 0 + list.add(2); // idx: 1 + list.add(3); // idx: 2 + + Assert.assertEquals(3, list.size()); + + list.add(4); // idx: 3 + + Assert.assertEquals(3, list.size()); + Assert.assertEquals(Arrays.asList(2, 3, 4), list.toList()); + + Assert.assertEquals(1, list.start()); + Assert.assertEquals(4, list.end()); + + list.removeBefore(3); + + Assert.assertEquals(1, list.size()); + + Assert.assertEquals(Arrays.asList(4), list.toList()); + + Assert.assertEquals(3, list.start()); + Assert.assertEquals(4, list.end()); + } + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testReadBefore() { + VirtualBoundedList list = new VirtualBoundedList(3); + + list.add(1); // idx: 0 + list.add(2); // idx: 1 + list.add(3); // idx: 2 + list.add(4); // idx: 3 + + list.get(0); + } + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testReadAfter() { + VirtualBoundedList list = new VirtualBoundedList(3); + + list.add(1); // idx: 0 + list.add(2); // idx: 1 + list.add(3); // idx: 2 + list.add(4); // idx: 3 + + list.get(4); + } +} From 5915fb3df3ddb708efd7e74a91f76237cfa9bc62 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Thu, 12 Dec 2013 21:03:37 +0100 Subject: [PATCH 083/441] Operation: Replay additional overloads --- rxjava-core/src/main/java/rx/Observable.java | 336 +++++++++++++++- .../java/rx/operators/OperationMulticast.java | 58 +++ .../java/rx/operators/OperationReplay.java | 50 ++- .../rx/operators/OperationReplayTest.java | 370 ++++++++++++++++++ 4 files changed, 790 insertions(+), 24 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 74a50c075f..f3dba504b2 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -73,6 +73,7 @@ import rx.operators.OperationOnExceptionResumeNextViaObservable; import rx.operators.OperationParallel; import rx.operators.OperationParallelMerge; +import rx.operators.OperationReplay; import rx.operators.OperationRetry; import rx.operators.OperationSample; import rx.operators.OperationScan; @@ -526,6 +527,24 @@ public ConnectableObservable multicast(Subject su return OperationMulticast.multicast(this, subject); } + /** + * Returns an observable sequence that contains the elements of a sequence + * produced by multicasting the source sequence within a selector function. + * + * @param subjectFactory the subject factory + * @param selector The selector function which can use the multicasted + * source sequence subject to the policies enforced by the + * created subject. + * @return the Observable sequence that contains the elements of a sequence + * produced by multicasting the source sequence within a selector function. + * + * @see MSDN: Observable.Multicast + */ + public Observable multicast( + final Func0> subjectFactory, + final Func1, ? extends Observable> selector) { + return OperationMulticast.multicast(this, subjectFactory, selector); + } /** * Allow the {@link RxJavaErrorHandler} to receive the exception from * onError. @@ -4277,20 +4296,327 @@ public Observable> maxBy(Func1 selector, Comparator public ConnectableObservable replay() { return OperationMulticast.multicast(this, ReplaySubject. create()); } - + /** * 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} on the given scheduler + * notifications to any future {@link Observer} on the given scheduler. * - * @param scheduler - * @return + * @param scheduler the scheduler where the Observers will receive the events + * @return 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} on the given scheduler * * @see MSDN: Observable.Replay */ public ConnectableObservable replay(Scheduler scheduler) { - return OperationMulticast.multicast(this, ReplaySubject. create()); + return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject.create(), scheduler)); + } + + /** + * Returns a connectable observable sequence that shares a single subscription + * to the underlying sequence replaying bufferSize notifications. + * + * @param bufferSize the buffer size + * @return a connectable observable sequence that shares a single subscription + * to the underlying sequence replaying bufferSize notifications + * + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(int bufferSize) { + return OperationMulticast.multicast(this, OperationReplay.replayBuffered(bufferSize)); + } + + /** + * Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications. + * + * @param bufferSize the buffer size + * @param scheduler the scheduler where the Observers will receive the events + * @return a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(int bufferSize, Scheduler scheduler) { + return OperationMulticast.multicast(this, + OperationReplay.createScheduledSubject( + OperationReplay.replayBuffered(bufferSize), scheduler)); + } + + /** + * Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window. + * + * @param time the window length + * @param unit the window length time unit + * @return a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(long time, TimeUnit unit) { + return replay(time, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window. + * + * @param time the window length + * @param unit the window length time unit + * @param scheduler the scheduler which is used as a time source for the window + * @return a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) { + return OperationMulticast.multicast(this, OperationReplay.replayWindowed(time, unit, -1, scheduler)); + } + + /** + * Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications within window. + * + * @param bufferSize the buffer size + * @param time the window length + * @param unit the window length time unit + * @return Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications within window + * + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) { + return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Returns a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications within window. + * + * @param bufferSize the buffer size + * @param time the window length + * @param unit the window length time unit + * @param scheduler the scheduler which is used as a time source for the window + * @return a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications within window + * + * @see MSDN: Observable.Replay + */ + public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) { + if (bufferSize < 0) { + throw new IllegalArgumentException("bufferSize < 0"); + } + return OperationMulticast.multicast(this, OperationReplay.replayWindowed(time, unit, bufferSize, scheduler)); + } + + /** + * Returns an observable sequence that is the result of invoking the selector + * on a connectable observable sequence that shares a single subscription to + * the underlying sequence and starts with initial value. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @return an observable sequence that is the result of invoking the selector + * on a connectable observable sequence that shares a single subscription to + * the underlying sequence and starts with initial value + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector) { + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return ReplaySubject.create(); + } + }, selector); + } + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param scheduler the scheduler where the replay is observed + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) { + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return OperationReplay.createScheduledSubject(ReplaySubject.create(), scheduler); + } + }, selector); + } + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param bufferSize the buffer size + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, final int bufferSize) { + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return OperationReplay.replayBuffered(bufferSize); + } + }, selector); + } + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param bufferSize the buffer size + * @param scheduler the scheduler where the replay is observed + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) { + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return OperationReplay.createScheduledSubject(OperationReplay.replayBuffered(bufferSize), scheduler); + } + }, selector); + } + + /** + * Returns an observable sequence that is the result of invoking + * the selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param time the window length + * @param unit the window length time unit + * @return an observable sequence that is the result of invoking + * the selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) { + return replay(selector, time, unit, Schedulers.threadPoolForComputation()); } + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param time the window length + * @param unit the window length time unit + * @param scheduler the scheduler which is used as a time source for the window + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications within window + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) { + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return OperationReplay.replayWindowed(time, unit, -1, scheduler); + } + }, selector); + } + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * within window. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param bufferSize the buffer size + * @param time the window length + * @param unit the window length time unit + * + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * within window + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) { + return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation()); + } + + + /** + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * within window. + * + * @param the return element type + * @param selector The selector function which can use the multicasted + * this sequence as many times as needed, without causing + * multiple subscriptions to this sequence. + * @param bufferSize the buffer size + * @param time the window length + * @param unit the window length time unit + * @param scheduler the scheduler which is used as a time source for the window + * + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying bufferSize notifications + * within window + * + * @see MSDN: Observable.Replay + */ + public Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) { + if (bufferSize < 0) { + throw new IllegalArgumentException("bufferSize < 0"); + } + return OperationMulticast.multicast(this, new Func0>() { + @Override + public Subject call() { + return OperationReplay.replayWindowed(time, unit, bufferSize, scheduler); + } + }, selector); + } + /** * Retry subscription to the source Observable when it calls * onError up to a certain number of retries. diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java index b634b2dbac..ef310986f5 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java @@ -16,10 +16,15 @@ package rx.operators; import rx.Observable; +import rx.Observable.OnSubscribeFunc; import rx.Observer; import rx.Subscription; import rx.observables.ConnectableObservable; import rx.subjects.Subject; +import rx.subscriptions.CompositeSubscription; +import rx.subscriptions.Subscriptions; +import rx.util.functions.Func0; +import rx.util.functions.Func1; public class OperationMulticast { public static ConnectableObservable multicast(Observable source, final Subject subject) { @@ -81,4 +86,57 @@ public void unsubscribe() { } } + /** + * Returns an observable sequence that contains the elements of a sequence + * produced by multicasting the source sequence within a selector function. + * + * @param source + * @param subjectFactory + * @param selector + * @return + * + * @see MSDN: Observable.Multicast + */ + public static Observable multicast( + final Observable source, + final Func0> subjectFactory, + final Func1, ? extends Observable> selector) { + return Observable.create(new MulticastSubscribeFunc(source, subjectFactory, selector)); + } + /** The multicast subscription function. */ + private static final class MulticastSubscribeFunc implements OnSubscribeFunc { + final Observable source; + final Func0> subjectFactory; + final Func1, ? extends Observable> resultSelector; + public MulticastSubscribeFunc(Observable source, + Func0> subjectFactory, + Func1, ? extends Observable> resultSelector) { + this.source = source; + this.subjectFactory = subjectFactory; + this.resultSelector = resultSelector; + } + @Override + public Subscription onSubscribe(Observer t1) { + Observable observable; + ConnectableObservable connectable; + try { + Subject subject = subjectFactory.call(); + + connectable = new MulticastConnectableObservable(source, subject); + + observable = resultSelector.call(connectable); + } catch (Throwable t) { + t1.onError(t); + return Subscriptions.empty(); + } + + CompositeSubscription csub = new CompositeSubscription(); + + csub.add(observable.subscribe(new SafeObserver( + new SafeObservableSubscription(csub), t1))); + csub.add(connectable.connect()); + + return csub; + } + } } diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java index 8f9e332c16..1a89b3d2ac 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java +++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java @@ -49,7 +49,7 @@ public final class OperationReplay { /** * Create a BoundedReplaySubject with the given buffer size. */ - public static Subject replayWithBufferSize(int bufferSize) { + public static Subject replayBuffered(int bufferSize) { return CustomReplaySubject.create(bufferSize); } /** @@ -61,22 +61,12 @@ public static Subject createScheduledSubject(Subject subject, Sc SubjectWrapper s = new SubjectWrapper(subscriberOf(observedOn), subject); return s; } - /** - * Return an OnSubscribeFunc which delegates the subscription to the given observable. - */ - public static OnSubscribeFunc subscriberOf(final Observable target) { - return new OnSubscribeFunc() { - @Override - public Subscription onSubscribe(Observer t1) { - return target.subscribe(t1); - } - }; - } /** * Create a CustomReplaySubject with the given time window length * and optional buffer size. * + * @param the source and return type * @param time the length of the time window * @param unit the unit of the time window length * @param bufferSize the buffer size if >= 0, otherwise, the buffer will be unlimited @@ -84,7 +74,7 @@ public Subscription onSubscribe(Observer t1) { * observers will not observe on this scheduler. * @return a Subject with the required replay behavior */ - public static Subject replayWithTimeWindowOrBufferSize(long time, TimeUnit unit, int bufferSize, final Scheduler scheduler) { + public static Subject replayWindowed(long time, TimeUnit unit, int bufferSize, final Scheduler scheduler) { final long ms = unit.toMillis(time); if (ms <= 0) { throw new IllegalArgumentException("The time window is less than 1 millisecond!"); @@ -134,6 +124,19 @@ public void call() { return brs; } + + /** + * Return an OnSubscribeFunc which delegates the subscription to the given observable. + */ + public static OnSubscribeFunc subscriberOf(final Observable target) { + return new OnSubscribeFunc() { + @Override + public Subscription onSubscribe(Observer t1) { + return target.subscribe(t1); + } + }; + } + /** * Subject that wraps another subject and uses a mapping function * to transform the received values. @@ -208,12 +211,15 @@ public void unlock() { } /** * Base interface for logically indexing a list. - * @param + * @param the value type */ public interface VirtualList { /** @return the number of elements in this list */ int size(); - /** Add an element to the list. */ + /** + * Add an element to the list. + * @param value the value to add + */ void add(T value); /** * Retrieve an element at the specified logical index. @@ -249,6 +255,11 @@ public interface VirtualList { * Clears and resets the indexes of the list. */ void reset(); + /** + * Returns the current content as a list. + * @return + */ + List toList(); } /** * Behaves like a normal, unbounded ArrayList but with virtual index. @@ -302,6 +313,10 @@ public void reset() { list.clear(); startIndex = 0; } + @Override + public List toList() { + return new ArrayList(list); + } } /** @@ -396,10 +411,7 @@ public void removeBefore(int index) { startIndex = index; head = head2 % maxSize; } - /** - * Returns a list with the current elements in this bounded list. - * @return - */ + @Override public List toList() { List r = new ArrayList(list.size() + 1); for (int i = head; i < head + count; i++) { diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java index 6db879582c..56f540d466 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java @@ -16,9 +16,18 @@ package rx.operators; import java.util.Arrays; +import java.util.concurrent.TimeUnit; import org.junit.Assert; import org.junit.Test; +import org.mockito.InOrder; +import static org.mockito.Mockito.*; +import rx.Observable; +import rx.Observer; +import rx.observables.ConnectableObservable; import rx.operators.OperationReplay.VirtualBoundedList; +import rx.schedulers.TestScheduler; +import rx.subjects.PublishSubject; +import rx.util.functions.Func1; public class OperationReplayTest { @Test @@ -70,4 +79,365 @@ public void testReadAfter() { list.get(4); } + @Test + public void testBufferedReplay() { + PublishSubject source = PublishSubject.create(); + + ConnectableObservable co = source.replay(3); + co.connect(); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + source.onNext(2); + source.onNext(3); + + inOrder.verify(observer1, times(1)).onNext(1); + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + + source.onNext(4); + source.onCompleted(); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + } + } + @Test + public void testWindowedReplay() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + ConnectableObservable co = source.replay(100, TimeUnit.MILLISECONDS, scheduler); + co.connect(); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(2); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(3); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onCompleted(); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + + inOrder.verify(observer1, times(1)).onNext(1); + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + inOrder.verify(observer1, times(1)).onNext(3); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + } + } + @Test + public void testReplaySelector() { + final Func1 dbl = new Func1() { + + @Override + public Integer call(Integer t1) { + return t1 * 2; + } + + }; + + Func1, Observable> selector = new Func1, Observable>() { + + @Override + public Observable call(Observable t1) { + return t1.map(dbl); + } + + }; + + PublishSubject source = PublishSubject.create(); + + Observable co = source.replay(selector); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + source.onNext(2); + source.onNext(3); + + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onNext(6); + + source.onNext(4); + source.onCompleted(); + inOrder.verify(observer1, times(1)).onNext(8); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + + } + + @Test + public void testBufferedReplaySelector() { + + final Func1 dbl = new Func1() { + + @Override + public Integer call(Integer t1) { + return t1 * 2; + } + + }; + + Func1, Observable> selector = new Func1, Observable>() { + + @Override + public Observable call(Observable t1) { + return t1.map(dbl); + } + + }; + + PublishSubject source = PublishSubject.create(); + + Observable co = source.replay(selector, 3); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + source.onNext(2); + source.onNext(3); + + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onNext(6); + + source.onNext(4); + source.onCompleted(); + inOrder.verify(observer1, times(1)).onNext(8); + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + } + } + @Test + public void testWindowedReplaySelector() { + + final Func1 dbl = new Func1() { + + @Override + public Integer call(Integer t1) { + return t1 * 2; + } + + }; + + Func1, Observable> selector = new Func1, Observable>() { + + @Override + public Observable call(Observable t1) { + return t1.map(dbl); + } + + }; + + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable co = source.replay(selector, 100, TimeUnit.MILLISECONDS, scheduler); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(2); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(3); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onCompleted(); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onNext(6); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + + } + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + inOrder.verify(observer1, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + } + } + @Test + public void testBufferedReplayError() { + PublishSubject source = PublishSubject.create(); + + ConnectableObservable co = source.replay(3); + co.connect(); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + source.onNext(2); + source.onNext(3); + + inOrder.verify(observer1, times(1)).onNext(1); + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + + source.onNext(4); + source.onError(new RuntimeException("Forced failure")); + + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class)); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onCompleted(); + + } + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + inOrder.verify(observer1, times(1)).onNext(4); + inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class)); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onCompleted(); + } + } + @Test + public void testWindowedReplayError() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + ConnectableObservable co = source.replay(100, TimeUnit.MILLISECONDS, scheduler); + co.connect(); + + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + + source.onNext(1); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(2); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onNext(3); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + source.onError(new RuntimeException("Forced failure")); + scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS); + + inOrder.verify(observer1, times(1)).onNext(1); + inOrder.verify(observer1, times(1)).onNext(2); + inOrder.verify(observer1, times(1)).onNext(3); + + inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class)); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onCompleted(); + + } + { + Observer observer1 = mock(Observer.class); + InOrder inOrder = inOrder(observer1); + + co.subscribe(observer1); + inOrder.verify(observer1, times(1)).onNext(3); + + inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class)); + inOrder.verifyNoMoreInteractions(); + verify(observer1, never()).onCompleted(); + } + } } From 16ca8283e27b3cc8f60d17cb9148735216627f8e Mon Sep 17 00:00:00 2001 From: George Campbell Date: Thu, 12 Dec 2013 13:43:08 -0800 Subject: [PATCH 084/441] Copied the code from OperationMerge --- .../rx/operators/OperationMergeDelayError.java | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java index dbca17522d..d899ca1149 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java @@ -24,6 +24,7 @@ import rx.Observable.OnSubscribeFunc; import rx.Observer; import rx.Subscription; +import rx.subscriptions.CompositeSubscription; import rx.util.CompositeException; /** @@ -151,13 +152,26 @@ private MergeDelayErrorObservable(Observable> } public Subscription onSubscribe(Observer actualObserver) { + CompositeSubscription completeSubscription = new CompositeSubscription(); + + /** + * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting. + *

    + * The calls from each sequence must be serialized. + *

    + * Bug report: https://github.com/Netflix/RxJava/issues/614 + */ + SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription); + completeSubscription.add(subscription); + SynchronizedObserver synchronizedObserver = new SynchronizedObserver(actualObserver, subscription); + /** * Subscribe to the parent Observable to get to the children Observables */ - sequences.subscribe(new ParentObserver(actualObserver)); + completeSubscription.add(sequences.subscribe(new ParentObserver(actualObserver))); /* return our subscription to allow unsubscribing */ - return ourSubscription; + return completeSubscription; } /** From d5d01594c63227ae2296ce4f2d60624fcf1ecaa0 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Thu, 12 Dec 2013 23:54:03 +0100 Subject: [PATCH 085/441] CombineLatest fix --- .../rx/operators/OperationCombineLatest.java | 367 ++++++-------- .../operators/OperationCombineLatestTest.java | 473 ++++++------------ 2 files changed, 306 insertions(+), 534 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java index 8a581667ae..e05d8f5343 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java +++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java @@ -15,17 +15,19 @@ */ package rx.operators; -import java.util.LinkedList; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.BitSet; import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; import rx.Subscription; +import rx.subscriptions.CompositeSubscription; +import rx.subscriptions.SingleAssignmentSubscription; import rx.util.functions.Func2; import rx.util.functions.Func3; import rx.util.functions.Func4; @@ -60,10 +62,7 @@ public class OperationCombineLatest { * @return A function from an observer to a subscription. This can be used to create an observable from. */ public static OnSubscribeFunc combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - return a; + return new CombineLatest(Arrays.asList(w0, w1), Functions.fromFunc(combineLatestFunction)); } /** @@ -71,11 +70,7 @@ public static OnSubscribeFunc combineLatest(Observable OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Func3 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2), Functions.fromFunc(combineLatestFunction)); } /** @@ -83,12 +78,7 @@ public static OnSubscribeFunc combineLatest(Observable OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Func4 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3), Functions.fromFunc(combineLatestFunction)); } /** @@ -96,13 +86,7 @@ public static OnSubscribeFunc combineLatest(Observable OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Func5 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - a.addObserver(new CombineObserver(a, w4)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4), Functions.fromFunc(combineLatestFunction)); } /** @@ -110,14 +94,7 @@ public static OnSubscribeFunc combineLatest(Observabl */ public static OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Func6 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - a.addObserver(new CombineObserver(a, w4)); - a.addObserver(new CombineObserver(a, w5)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5), Functions.fromFunc(combineLatestFunction)); } /** @@ -125,15 +102,7 @@ public static OnSubscribeFunc combineLatest(Obser */ public static OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6, Func7 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - a.addObserver(new CombineObserver(a, w4)); - a.addObserver(new CombineObserver(a, w5)); - a.addObserver(new CombineObserver(a, w6)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5, w6), Functions.fromFunc(combineLatestFunction)); } /** @@ -141,16 +110,7 @@ public static OnSubscribeFunc combineLatest(O */ public static OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6, Observable w7, Func8 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - a.addObserver(new CombineObserver(a, w4)); - a.addObserver(new CombineObserver(a, w5)); - a.addObserver(new CombineObserver(a, w6)); - a.addObserver(new CombineObserver(a, w7)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5, w6, w7), Functions.fromFunc(combineLatestFunction)); } /** @@ -159,190 +119,163 @@ public static OnSubscribeFunc combineLate public static OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6, Observable w7, Observable w8, Func9 combineLatestFunction) { - Aggregator a = new Aggregator(Functions.fromFunc(combineLatestFunction)); - a.addObserver(new CombineObserver(a, w0)); - a.addObserver(new CombineObserver(a, w1)); - a.addObserver(new CombineObserver(a, w2)); - a.addObserver(new CombineObserver(a, w3)); - a.addObserver(new CombineObserver(a, w4)); - a.addObserver(new CombineObserver(a, w5)); - a.addObserver(new CombineObserver(a, w6)); - a.addObserver(new CombineObserver(a, w7)); - a.addObserver(new CombineObserver(a, w8)); - return a; + return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5, w6, w7, w8), Functions.fromFunc(combineLatestFunction)); } - /* package accessible for unit tests */static class CombineObserver implements Observer { - final Observable w; - final Aggregator a; - private Subscription subscription; - - public CombineObserver(Aggregator a, Observable w) { - this.a = a; - this.w = w; - } - - private void startWatching() { - if (subscription != null) { - throw new RuntimeException("This should only be called once."); + static final class CombineLatest implements OnSubscribeFunc { + final List> sources; + final FuncN combiner; + public CombineLatest(Iterable> sources, FuncN combiner) { + this.sources = new ArrayList>(); + this.combiner = combiner; + for (Observable source : sources) { + this.sources.add(source); } - subscription = w.subscribe(this); - } - - @Override - public void onCompleted() { - a.complete(this); } @Override - public void onError(Throwable e) { - a.error(e); - } - - @Override - public void onNext(T args) { - a.next(this, args); - } - } - - /** - * Receive notifications from each of the observables we are reducing and execute the combineLatestFunction - * whenever we have received an event from one of the observables, as soon as each Observable has received - * at least one event. - */ - /* package accessible for unit tests */static class Aggregator implements OnSubscribeFunc { - - private volatile Observer observer; - - private final FuncN combineLatestFunction; - private final AtomicBoolean running = new AtomicBoolean(true); - - // Stores how many observers have already completed - private final AtomicInteger numCompleted = new AtomicInteger(0); - - /** - * The latest value from each observer. - */ - private final Map, Object> latestValue = new ConcurrentHashMap, Object>(); - - /** - * Ordered list of observers to combine. - * No synchronization is necessary as these can not be added or changed asynchronously. - */ - private final List> observers = new LinkedList>(); - - public Aggregator(FuncN combineLatestFunction) { - this.combineLatestFunction = combineLatestFunction; - } - - /** - * Receive notification of a Observer starting (meaning we should require it for aggregation) - * - * @param w - * The observer to add. - */ - void addObserver(CombineObserver w) { - observers.add(w); - } - - /** - * Receive notification of a Observer completing its iterations. - * - * @param w - * The observer that has completed. - */ - void complete(CombineObserver w) { - int completed = numCompleted.incrementAndGet(); - // if all CombineObservers are completed, we mark the whole thing as completed - if (completed == observers.size()) { - if (running.get()) { - // mark ourselves as done - observer.onCompleted(); - // just to ensure we stop processing in case we receive more onNext/complete/error calls after this - running.set(false); + public Subscription onSubscribe(Observer t1) { + CompositeSubscription csub = new CompositeSubscription(); + + Collector collector = new Collector(t1, csub, sources.size()); + + int index = 0; + List observers = new ArrayList(sources.size() + 1); + for (Observable source : sources) { + SingleAssignmentSubscription sas = new SingleAssignmentSubscription(); + csub.add(sas); + observers.add(new SourceObserver(collector, sas, index, source)); + index++; + } + + for (SourceObserver so : observers) { + // if we run to completion, don't bother any further + if (!csub.isUnsubscribed()) { + so.connect(); } } + + return csub; } - /** - * Receive error for a Observer. Throw the error up the chain and stop processing. + * The collector that combines the latest values from many sources. */ - void error(Throwable e) { - observer.onError(e); - /* tell all observers to unsubscribe since we had an error */ - stop(); - } - - /** - * Receive the next value from an observer. - *

    - * If we have received values from all observers, trigger the combineLatest function, otherwise store the value and keep waiting. - * - * @param w - * @param arg - */ - void next(CombineObserver w, T arg) { - if (observer == null) { - throw new RuntimeException("This shouldn't be running if an Observer isn't registered"); + final class Collector { + final Observer observer; + final Subscription cancel; + final Lock lock; + final Object[] values; + /** Bitmap to keep track who produced a value already. */ + final BitSet hasValue; + /** Bitmap to keep track who has completed. */ + final BitSet completed; + /** Number of source observers who have produced a value. */ + int hasCount; + /** Number of completed source observers. */ + int completedCount; + public Collector(Observer observer, Subscription cancel, int count) { + this.observer = observer; + this.cancel = cancel; + this.values = new Object[count]; + this.hasValue = new BitSet(count); + this.completed = new BitSet(count); + this.lock = new ReentrantLock(); } - - /* if we've been 'unsubscribed' don't process anything further even if the things we're watching keep sending (likely because they are not responding to the unsubscribe call) */ - if (!running.get()) { - return; + public void next(int index, T value) { + lock.lock(); + try { + values[index] = value; + if (!hasValue.get(index)) { + hasValue.set(index); + hasCount++; + } + if (hasCount == values.length) { + // clone: defensive copy due to varargs + try { + observer.onNext(combiner.call(values.clone())); + } catch (Throwable t) { + terminate(); + observer.onError(t); + cancel.unsubscribe(); + } + } + } finally { + lock.unlock(); + } } - - // remember this as the latest value for this observer - latestValue.put(w, arg); - - if (latestValue.size() < observers.size()) { - // we don't have a value yet for each observer to combine, so we don't have a combined value yet either - return; + public void error(int index, Throwable e) { + lock.lock(); + try { + if (!isTerminated()) { + terminate(); + observer.onError(e); + cancel.unsubscribe(); + } + } finally { + lock.unlock(); + } } - - Object[] argsToCombineLatest = new Object[observers.size()]; - int i = 0; - for (CombineObserver _w : observers) { - argsToCombineLatest[i++] = latestValue.get(_w); + boolean isTerminated() { + return completedCount == values.length + 1; } - - try { - R combinedValue = combineLatestFunction.call(argsToCombineLatest); - observer.onNext(combinedValue); - } catch (Throwable ex) { - observer.onError(ex); + void terminate() { + completedCount = values.length + 1; + Arrays.fill(values, null); + } + public void completed(int index) { + lock.lock(); + try { + if (!completed.get(index)) { + completed.set(index); + completedCount++; + } + if ((!hasValue.get(index) || completedCount == values.length) + && !isTerminated()) { + terminate(); + observer.onCompleted(); + cancel.unsubscribe(); + } + } finally { + lock.unlock(); + } + } } - - @Override - public Subscription onSubscribe(Observer observer) { - if (this.observer != null) { - throw new IllegalStateException("Only one Observer can subscribe to this Observable."); + /** + * Observes a specific source and communicates with the collector. + */ + final class SourceObserver implements Observer { + final SingleAssignmentSubscription self; + final Collector collector; + final int index; + Observable source; + public SourceObserver(Collector collector, + SingleAssignmentSubscription self, int index, + Observable source) { + this.self = self; + this.collector = collector; + this.index = index; + this.source = source; } - - SafeObservableSubscription subscription = new SafeObservableSubscription(new Subscription() { - @Override - public void unsubscribe() { - stop(); - } - }); - this.observer = new SynchronizedObserver(observer, subscription); - - /* start the observers */ - for (CombineObserver rw : observers) { - rw.startWatching(); + @Override + public void onNext(T args) { + collector.next(index, args); } - return subscription; - } + @Override + public void onError(Throwable e) { + collector.error(index, e); + } - private void stop() { - /* tell ourselves to stop processing onNext events */ - running.set(false); - /* propogate to all observers to unsubscribe */ - for (CombineObserver rw : observers) { - if (rw.subscription != null) { - rw.subscription.unsubscribe(); - } + @Override + public void onCompleted() { + collector.completed(index); + self.unsubscribe(); + } + /** Connect to the source. */ + void connect() { + self.set(source.subscribe(this)); + source = null; } } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java index c576337e1e..70d34bd887 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java @@ -28,8 +28,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; -import rx.operators.OperationCombineLatest.Aggregator; -import rx.operators.OperationCombineLatest.CombineObserver; +import rx.subjects.PublishSubject; import rx.subscriptions.Subscriptions; import rx.util.functions.Func2; import rx.util.functions.Func3; @@ -176,321 +175,7 @@ public void testCombineLatestWithInterleavingSequences() { inOrder.verify(w, times(1)).onCompleted(); } - /** - * Testing internal private logic due to the complexity so I want to use TDD to test as a I build it rather than relying purely on the overall functionality expected by the public methods. - */ - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorSimple() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, "world"); - - InOrder inOrder = inOrder(aObserver); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - inOrder.verify(aObserver, times(1)).onNext("helloworld"); - - a.next(r1, "hello "); - a.next(r2, "again"); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - inOrder.verify(aObserver, times(1)).onNext("hello again"); - - a.complete(r1); - a.complete(r2); - - inOrder.verify(aObserver, never()).onNext(anyString()); - verify(aObserver, times(1)).onCompleted(); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorDifferentSizedResultsWithOnComplete() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, "world"); - a.complete(r2); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("helloworld"); - - a.next(r1, "hi"); - a.complete(r1); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, times(1)).onCompleted(); - verify(aObserver, times(1)).onNext("hiworld"); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregateMultipleTypes() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, "world"); - a.complete(r2); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("helloworld"); - - a.next(r1, "hi"); - a.complete(r1); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, times(1)).onCompleted(); - verify(aObserver, times(1)).onNext("hiworld"); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregate3Types() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - CombineObserver r3 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - a.addObserver(r3); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, 2); - a.next(r3, new int[] { 5, 6, 7 }); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("hello2[5, 6, 7]"); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorsWithDifferentSizesAndTiming() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "one"); - a.next(r1, "two"); - a.next(r1, "three"); - a.next(r2, "A"); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("threeA"); - - a.next(r1, "four"); - a.complete(r1); - a.next(r2, "B"); - verify(aObserver, times(1)).onNext("fourB"); - a.next(r2, "C"); - verify(aObserver, times(1)).onNext("fourC"); - a.next(r2, "D"); - verify(aObserver, times(1)).onNext("fourD"); - a.next(r2, "E"); - verify(aObserver, times(1)).onNext("fourE"); - a.complete(r2); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, times(1)).onCompleted(); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorError() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, "world"); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("helloworld"); - - a.error(new RuntimeException("")); - a.next(r1, "hello"); - a.next(r2, "again"); - - verify(aObserver, times(1)).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - // we don't want to be called again after an error - verify(aObserver, times(0)).onNext("helloagain"); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorUnsubscribe() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Subscription subscription = Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "hello"); - a.next(r2, "world"); - - verify(aObserver, never()).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - verify(aObserver, times(1)).onNext("helloworld"); - - subscription.unsubscribe(); - a.next(r1, "hello"); - a.next(r2, "again"); - - verify(aObserver, times(0)).onError(any(Throwable.class)); - verify(aObserver, never()).onCompleted(); - // we don't want to be called again after an error - verify(aObserver, times(0)).onNext("helloagain"); - } - - @SuppressWarnings("unchecked") - /* mock calls don't do generics */ - @Test - public void testAggregatorEarlyCompletion() { - FuncN combineLatestFunction = getConcatCombineLatestFunction(); - /* create the aggregator which will execute the combineLatest function when all Observables provide values */ - Aggregator a = new Aggregator(combineLatestFunction); - - /* define a Observer to receive aggregated events */ - Observer aObserver = mock(Observer.class); - Observable.create(a).subscribe(aObserver); - - /* mock the Observable Observers that are 'pushing' data for us */ - CombineObserver r1 = mock(CombineObserver.class); - CombineObserver r2 = mock(CombineObserver.class); - - /* pretend we're starting up */ - a.addObserver(r1); - a.addObserver(r2); - - /* simulate the Observables pushing data into the aggregator */ - a.next(r1, "one"); - a.next(r1, "two"); - a.complete(r1); - a.next(r2, "A"); - - InOrder inOrder = inOrder(aObserver); - - inOrder.verify(aObserver, never()).onError(any(Throwable.class)); - inOrder.verify(aObserver, never()).onCompleted(); - inOrder.verify(aObserver, times(1)).onNext("twoA"); - - a.complete(r2); - - inOrder.verify(aObserver, never()).onError(any(Throwable.class)); - inOrder.verify(aObserver, times(1)).onCompleted(); - // we shouldn't get this since completed is called before any other onNext calls could trigger this - inOrder.verify(aObserver, never()).onNext(anyString()); - } - + @SuppressWarnings("unchecked") /* mock calls don't do generics */ @Test @@ -633,4 +318,158 @@ public Subscription onSubscribe(Observer observer) { } } + + Func2 or = new Func2() { + @Override + public Integer call(Integer t1, Integer t2) { + return t1 | t2; + } + }; + + @Test + public void combineSimple() { + PublishSubject a = PublishSubject.create(); + PublishSubject b = PublishSubject.create(); + + Observable source = Observable.combineLatest(a, b, or); + + Observer observer = mock(Observer.class); + + source.subscribe(observer); + + InOrder inOrder = inOrder(observer); + + a.onNext(1); + + inOrder.verify(observer, never()).onNext(any()); + + a.onNext(2); + + inOrder.verify(observer, never()).onNext(any()); + + b.onNext(0x10); + + inOrder.verify(observer, times(1)).onNext(0x12); + + b.onNext(0x20); + inOrder.verify(observer, times(1)).onNext(0x22); + + b.onCompleted(); + + inOrder.verify(observer, never()).onCompleted(); + + a.onCompleted(); + + inOrder.verify(observer, times(1)).onCompleted(); + + a.onNext(3); + b.onNext(0x30); + a.onCompleted(); + b.onCompleted(); + + inOrder.verifyNoMoreInteractions(); + verify(observer, never()).onError(any(Throwable.class)); + } + + @Test + public void combineMultipleObservers() { + PublishSubject a = PublishSubject.create(); + PublishSubject b = PublishSubject.create(); + + Observable source = Observable.combineLatest(a, b, or); + + Observer observer1 = mock(Observer.class); + Observer observer2 = mock(Observer.class); + + source.subscribe(observer1); + source.subscribe(observer2); + + InOrder inOrder1 = inOrder(observer1); + InOrder inOrder2 = inOrder(observer2); + + a.onNext(1); + + inOrder1.verify(observer1, never()).onNext(any()); + inOrder2.verify(observer2, never()).onNext(any()); + + a.onNext(2); + + inOrder1.verify(observer1, never()).onNext(any()); + inOrder2.verify(observer2, never()).onNext(any()); + + b.onNext(0x10); + + inOrder1.verify(observer1, times(1)).onNext(0x12); + inOrder2.verify(observer2, times(1)).onNext(0x12); + + b.onNext(0x20); + inOrder1.verify(observer1, times(1)).onNext(0x22); + inOrder2.verify(observer2, times(1)).onNext(0x22); + + b.onCompleted(); + + inOrder1.verify(observer1, never()).onCompleted(); + inOrder2.verify(observer2, never()).onCompleted(); + + a.onCompleted(); + + inOrder1.verify(observer1, times(1)).onCompleted(); + inOrder2.verify(observer2, times(1)).onCompleted(); + + a.onNext(3); + b.onNext(0x30); + a.onCompleted(); + b.onCompleted(); + + inOrder1.verifyNoMoreInteractions(); + inOrder2.verifyNoMoreInteractions(); + verify(observer1, never()).onError(any(Throwable.class)); + verify(observer2, never()).onError(any(Throwable.class)); + } + @Test + public void testFirstNeverProduces() { + PublishSubject a = PublishSubject.create(); + PublishSubject b = PublishSubject.create(); + + Observable source = Observable.combineLatest(a, b, or); + + Observer observer = mock(Observer.class); + + source.subscribe(observer); + + InOrder inOrder = inOrder(observer); + + b.onNext(0x10); + b.onNext(0x20); + + a.onCompleted(); + + inOrder.verify(observer, times(1)).onCompleted(); + verify(observer, never()).onNext(any()); + verify(observer, never()).onError(any(Throwable.class)); + } + + @Test + public void testSecondNeverProduces() { + PublishSubject a = PublishSubject.create(); + PublishSubject b = PublishSubject.create(); + + Observable source = Observable.combineLatest(a, b, or); + + Observer observer = mock(Observer.class); + + source.subscribe(observer); + + InOrder inOrder = inOrder(observer); + + a.onNext(0x1); + a.onNext(0x2); + + b.onCompleted(); + a.onCompleted(); + + inOrder.verify(observer, times(1)).onCompleted(); + verify(observer, never()).onNext(any()); + verify(observer, never()).onError(any(Throwable.class)); + } } From 1338e87802c1e709bef619fba0e94c2db331b028 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Fri, 13 Dec 2013 00:03:42 +0100 Subject: [PATCH 086/441] Moved onError, onCompleted and cancel.unsubscribed outside the lock --- .../rx/operators/OperationCombineLatest.java | 51 ++++++++++++------- 1 file changed, 33 insertions(+), 18 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java index e05d8f5343..fcf1caf051 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java +++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java @@ -182,38 +182,49 @@ public Collector(Observer observer, Subscription cancel, int count) { this.lock = new ReentrantLock(); } public void next(int index, T value) { + Throwable err = null; lock.lock(); try { - values[index] = value; - if (!hasValue.get(index)) { - hasValue.set(index); - hasCount++; - } - if (hasCount == values.length) { - // clone: defensive copy due to varargs - try { - observer.onNext(combiner.call(values.clone())); - } catch (Throwable t) { - terminate(); - observer.onError(t); - cancel.unsubscribe(); + if (!isTerminated()) { + values[index] = value; + if (!hasValue.get(index)) { + hasValue.set(index); + hasCount++; + } + if (hasCount == values.length) { + // clone: defensive copy due to varargs + try { + observer.onNext(combiner.call(values.clone())); + } catch (Throwable t) { + terminate(); + err = t; + } } } } finally { lock.unlock(); } + if (err != null) { + // no need to lock here + observer.onError(err); + cancel.unsubscribe(); + } } public void error(int index, Throwable e) { + boolean unsub = false; lock.lock(); try { if (!isTerminated()) { terminate(); - observer.onError(e); - cancel.unsubscribe(); + unsub = true; } } finally { lock.unlock(); } + if (unsub) { + observer.onError(e); + cancel.unsubscribe(); + } } boolean isTerminated() { return completedCount == values.length + 1; @@ -223,6 +234,7 @@ void terminate() { Arrays.fill(values, null); } public void completed(int index) { + boolean unsub = false; lock.lock(); try { if (!completed.get(index)) { @@ -232,13 +244,16 @@ public void completed(int index) { if ((!hasValue.get(index) || completedCount == values.length) && !isTerminated()) { terminate(); - observer.onCompleted(); - cancel.unsubscribe(); + unsub = true; } } finally { lock.unlock(); } - + if (unsub) { + // no need to hold a lock at this point + observer.onCompleted(); + cancel.unsubscribe(); + } } } /** From bdf70f5716276c6cfd173db8b167644dee226b86 Mon Sep 17 00:00:00 2001 From: David Gross Date: Thu, 12 Dec 2013 16:57:18 -0800 Subject: [PATCH 087/441] replay() and timer() javadocs: diagrams & wiki links --- rxjava-core/src/main/java/rx/Observable.java | 300 +++++++++++-------- 1 file changed, 180 insertions(+), 120 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index b33e33136c..5d98df26b9 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -532,13 +532,14 @@ public ConnectableObservable multicast(Subject su * produced by multicasting the source sequence within a selector function. * * @param subjectFactory the subject factory - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * source sequence subject to the policies enforced by the - * created subject. + * created subject * @return the Observable sequence that contains the elements of a sequence - * produced by multicasting the source sequence within a selector function. - * - * @see MSDN: Observable.Multicast + * produced by multicasting the source sequence within a selector + * function + * @see RxJava: Observable.publish() and Observable.multicast() + * @see MSDN: Observable.Multicast */ public Observable multicast( final Func0> subjectFactory, @@ -2044,31 +2045,44 @@ public static Observable timer(long delay, TimeUnit unit, Scheduler schedu } /** - * Return an Observable which emits a 0L after the initialDelay and ever increasing - * numbers after each period. + * Return an Observable which emits a 0L after the {@code initialDelay} and + * ever increasing numbers after each {@code period}. + *

    + * * - * @param initialDelay the initial delay time to wait before emitting the first value of 0L + * @param initialDelay the initial delay time to wait before emitting the + * first value of 0L * @param period the time period after emitting the subsequent numbers - * @param unit the time unit for both initialDelay and period - * @return an Observable which emits a 0L after the initialDelay and ever increasing - * numbers after each period - * @see MSDN: Observable.Timer + * @param unit the time unit for both initialDelay and + * period + * @return an Observable which emits a 0L after the {@code initialDelay} and + * ever increasing numbers after each {@code period} + * @see RxJava Wiki: timer() + * @see MSDN: Observable.Timer */ public static Observable timer(long initialDelay, long period, TimeUnit unit) { return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation()); } /** - * Return an Observable which emits a 0L after the initialDelay and ever increasing - * numbers after each period while running on the given scheduler. + * Return an Observable which emits a 0L after the {@code initialDelay} and + * ever increasing numbers after each {@code period} while running on the + * given {@code scheduler}. + *

    + * * - * @param initialDelay the initial delay time to wait before emitting the first value of 0L + * @param initialDelay the initial delay time to wait before emitting the + * first value of 0L * @param period the time period after emitting the subsequent numbers - * @param unit the time unit for both initialDelay and period - * @param scheduler the scheduler where the waiting happens and value emissions run. - * @return an Observable which emits a 0L after the initialDelay and ever increasing - * numbers after each period while running on the given scheduler - * @see MSDN: Observable.Timer + * @param unit the time unit for both initialDelay and + * period + * @param scheduler the scheduler on which the waiting happens and value + * emissions run + * @return an Observable that emits a 0L after the {@code initialDelay} and + * ever increasing numbers after each {@code period} while running + * on the given {@code scheduler} + * @see RxJava Wiki: timer() + * @see MSDN: Observable.Timer */ public static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) { return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler)); @@ -4332,27 +4346,35 @@ public ConnectableObservable replay() { * 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} on the given scheduler. + *

    + * * - * @param scheduler the scheduler where the Observers will receive the events + * @param scheduler the scheduler on which the Observers will observe the + * emitted items * @return 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} on the given scheduler - * - * @see MSDN: Observable.Replay + * to the source Observable that will replay all of its items and + * notifications to any future {@link Observer} on the given + * scheduler + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(Scheduler scheduler) { return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject.create(), scheduler)); } /** - * Returns a connectable observable sequence that shares a single subscription - * to the underlying sequence replaying bufferSize notifications. + * Returns a connectable observable sequence that shares a single + * subscription to the source Observable that replays at most + * {@code bufferSize} items emitted by that Observable. + *

    + * * * @param bufferSize the buffer size - * @return a connectable observable sequence that shares a single subscription - * to the underlying sequence replaying bufferSize notifications - * - * @see MSDN: Observable.Replay + * @return a connectable observable sequence that shares a single + * subscription to the source Observable and replays at most + * {@code bufferSize} items emitted by that Observable + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(int bufferSize) { return OperationMulticast.multicast(this, OperationReplay.replayBuffered(bufferSize)); @@ -4360,14 +4382,19 @@ public ConnectableObservable replay(int bufferSize) { /** * Returns a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications. + * subscription to the source Observable and replays at most + * {@code bufferSize} items emitted by that Observable. + *

    + * * * @param bufferSize the buffer size - * @param scheduler the scheduler where the Observers will receive the events + * @param scheduler the scheduler on which the Observers will observe the + * emitted items * @return a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * - * @see MSDN: Observable.Replay + * subscription to the source Observable and replays at most + * {@code bufferSize} items emitted by that Observable + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(int bufferSize, Scheduler scheduler) { return OperationMulticast.multicast(this, @@ -4377,13 +4404,19 @@ public ConnectableObservable replay(int bufferSize, Scheduler scheduler) { /** * Returns a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window. + * subscription to the source Observable and replays all items emitted by + * that Observable within a time window. + *

    + * * * @param time the window length * @param unit the window length time unit * @return a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window - * @see MSDN: Observable.Replay + * subscription to the source Observable and that replays all items + * emitted by that Observable during the window defined by + * {@code time} and {@code unit} + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(long time, TimeUnit unit) { return replay(time, unit, Schedulers.threadPoolForComputation()); @@ -4391,14 +4424,21 @@ public ConnectableObservable replay(long time, TimeUnit unit) { /** * Returns a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window. + * subscription to the source Observable and replays all items emitted by + * that Observable within a time window. + *

    + * * * @param time the window length * @param unit the window length time unit - * @param scheduler the scheduler which is used as a time source for the window + * @param scheduler the scheduler that is used as a time source for the + * window * @return a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window - * @see MSDN: Observable.Replay + * subscription to the source Observable and replays all items + * emitted by that Observable within the window defined by + * {@code time} and {@code unit} + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) { return OperationMulticast.multicast(this, OperationReplay.replayWindowed(time, unit, -1, scheduler)); @@ -4406,15 +4446,18 @@ public ConnectableObservable replay(long time, TimeUnit unit, Scheduler sched /** * Returns a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications within window. + * subscription to the underlying sequence replaying {@code bufferSize} + * notifications within window. + *

    + * * * @param bufferSize the buffer size * @param time the window length * @param unit the window length time unit * @return Returns a connectable observable sequence that shares a single * subscription to the underlying sequence replaying bufferSize notifications within window - * - * @see MSDN: Observable.Replay + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) { return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation()); @@ -4422,16 +4465,23 @@ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) /** * Returns a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications within window. + * subscription to the underlying sequence and that replays a maximum of + * {@code bufferSize} items that are emitted within the window defined by + * {@code time} and {@code unit}. + *

    + * * * @param bufferSize the buffer size * @param time the window length * @param unit the window length time unit - * @param scheduler the scheduler which is used as a time source for the window + * @param scheduler the scheduler that is used as a time source for the + * window * @return a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications within window - * - * @see MSDN: Observable.Replay + * subscription to the underlying sequence that replays a maximum of + * {@code bufferSize} items that are emitted within the window + * defined by {@code time} and {@code unit} + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) { if (bufferSize < 0) { @@ -4441,19 +4491,20 @@ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, } /** - * Returns an observable sequence that is the result of invoking the selector - * on a connectable observable sequence that shares a single subscription to - * the underlying sequence and starts with initial value. + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence and starts with initial value. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. - * @return an observable sequence that is the result of invoking the selector - * on a connectable observable sequence that shares a single subscription to - * the underlying sequence and starts with initial value - * - * @see MSDN: Observable.Replay + * multiple subscriptions to this sequence + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence and starts with + * initial value + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector) { return OperationMulticast.multicast(this, new Func0>() { @@ -4470,15 +4521,16 @@ public Subject call() { * subscription to the underlying sequence replaying all notifications. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param scheduler the scheduler where the replay is observed * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying all + * notifications + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) { return OperationMulticast.multicast(this, new Func0>() { @@ -4492,18 +4544,20 @@ public Subject call() { /** * Returns an observable sequence that is the result of invoking the * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications. + * subscription to the underlying sequence replaying {@code bufferSize} + * notifications. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param bufferSize the buffer size * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying + * {@code bufferSize} notifications + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, final int bufferSize) { return OperationMulticast.multicast(this, new Func0>() { @@ -4517,19 +4571,21 @@ public Subject call() { /** * Returns an observable sequence that is the result of invoking the * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications. + * subscription to the underlying sequence replaying {@code bufferSize} + * notifications. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param bufferSize the buffer size * @param scheduler the scheduler where the replay is observed * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying + * {@code bufferSize} notifications + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) { return OperationMulticast.multicast(this, new Func0>() { @@ -4541,21 +4597,23 @@ public Subject call() { } /** - * Returns an observable sequence that is the result of invoking - * the selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window. + * Returns an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a single + * subscription to the underlying sequence replaying all notifications + * within window. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param time the window length * @param unit the window length time unit - * @return an observable sequence that is the result of invoking - * the selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window - * - * @see MSDN: Observable.Replay + * @return an observable sequence that is the result of invoking the + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying all + * notifications within window + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) { return replay(selector, time, unit, Schedulers.threadPoolForComputation()); @@ -4564,20 +4622,23 @@ public Observable replay(Func1, ? extends Observabl /** * Returns an observable sequence that is the result of invoking the * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window. + * subscription to the underlying sequence replaying all notifications + * within window. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param time the window length * @param unit the window length time unit - * @param scheduler the scheduler which is used as a time source for the window + * @param scheduler the scheduler that is used as a time source for the + * window * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying all notifications within window - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying all + * notifications within window + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) { return OperationMulticast.multicast(this, new Func0>() { @@ -4591,23 +4652,22 @@ public Subject call() { /** * Returns an observable sequence that is the result of invoking the * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * within window. + * subscription to the underlying sequence replaying {@code bufferSize} + * notifications within window. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param bufferSize the buffer size * @param time the window length * @param unit the window length time unit - * * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * within window - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying + * {@code bufferSize} notifications within window + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) { return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation()); @@ -4617,24 +4677,24 @@ public Observable replay(Func1, ? extends Observabl /** * Returns an observable sequence that is the result of invoking the * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * within window. + * subscription to the underlying sequence replaying {@code bufferSize} + * notifications within window. * * @param the return element type - * @param selector The selector function which can use the multicasted + * @param selector the selector function which can use the multicasted * this sequence as many times as needed, without causing - * multiple subscriptions to this sequence. + * multiple subscriptions to this sequence * @param bufferSize the buffer size * @param time the window length * @param unit the window length time unit - * @param scheduler the scheduler which is used as a time source for the window - * + * @param scheduler the scheduler which is used as a time source for the + * window * @return an observable sequence that is the result of invoking the - * selector on a connectable observable sequence that shares a single - * subscription to the underlying sequence replaying bufferSize notifications - * within window - * - * @see MSDN: Observable.Replay + * selector on a connectable observable sequence that shares a + * single subscription to the underlying sequence replaying + * {@code bufferSize} notifications within window + * @see RxJava Wiki: replay() + * @see MSDN: Observable.Replay */ public Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) { if (bufferSize < 0) { From 39d49fcf3c7c1716c6d0d0c048598aa131899a1d Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Thu, 12 Dec 2013 23:23:38 -0800 Subject: [PATCH 088/441] ObserveOn Fixes - fix subscription leak (Composite+MultipleAssignment instead of just Composite) - add unit tests --- .../java/rx/operators/OperationObserveOn.java | 78 ++++++++------- .../src/test/java/rx/ErrorHandlingTests.java | 98 +++++++++++++++++++ .../rx/operators/OperationObserveOnTest.java | 64 ++++++------ 3 files changed, 174 insertions(+), 66 deletions(-) create mode 100644 rxjava-core/src/test/java/rx/ErrorHandlingTests.java diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java index fed1cf4bb0..2f569ea75f 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java +++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java @@ -27,7 +27,7 @@ import rx.schedulers.CurrentThreadScheduler; import rx.schedulers.ImmediateScheduler; import rx.subscriptions.CompositeSubscription; -import rx.subscriptions.Subscriptions; +import rx.subscriptions.MultipleAssignmentSubscription; import rx.util.functions.Action0; import rx.util.functions.Action1; import rx.util.functions.Func2; @@ -64,62 +64,66 @@ public Subscription onSubscribe(final Observer observer) { return new Observation(observer).init(); } } + /** Observe through individual queue per observer. */ - private class Observation implements Action1> { + private class Observation { final Observer observer; - final CompositeSubscription s; - final ConcurrentLinkedQueue> queue; - final AtomicInteger counter; + final CompositeSubscription compositeSubscription = new CompositeSubscription(); + final MultipleAssignmentSubscription recursiveSubscription = new MultipleAssignmentSubscription(); + final ConcurrentLinkedQueue> queue = new ConcurrentLinkedQueue>(); + final AtomicInteger counter = new AtomicInteger(0); private volatile Scheduler recursiveScheduler; + public Observation(Observer observer) { this.observer = observer; - this.queue = new ConcurrentLinkedQueue>(); - this.counter = new AtomicInteger(0); - this.s = new CompositeSubscription(); } + public Subscription init() { - s.add(source.materialize().subscribe(this)); - return s; + compositeSubscription.add(source.materialize().subscribe(new SourceObserver())); + return compositeSubscription; } - @Override - public void call(Notification e) { - queue.offer(e); - if (counter.getAndIncrement() == 0) { - if (recursiveScheduler == null) { - s.add(scheduler.schedule(null, new Func2() { + private class SourceObserver implements Action1> { + + @Override + public void call(Notification e) { + queue.offer(e); + if (counter.getAndIncrement() == 0) { + if (recursiveScheduler == null) { + // compositeSubscription for the outer scheduler, recursive for inner + compositeSubscription.add(scheduler.schedule(null, new Func2() { @Override public Subscription call(Scheduler innerScheduler, T state) { // record innerScheduler so 'processQueue' can use it for all subsequent executions recursiveScheduler = innerScheduler; - + // once we have the innerScheduler we can start doing real work processQueue(); - - return Subscriptions.empty(); + return recursiveSubscription; } })); - } else { - processQueue(); + } else { + processQueue(); + } } } - } - void processQueue() { - s.add(recursiveScheduler.schedule(new Action1() { - @Override - public void call(Action0 self) { - Notification not = queue.poll(); - if (not != null) { - not.accept(observer); - } - // decrement count and if we still have work to do - // recursively schedule ourselves to process again - if (counter.decrementAndGet() > 0) { - self.call(); - } + void processQueue() { + recursiveSubscription.setSubscription(recursiveScheduler.schedule(new Action1() { + @Override + public void call(Action0 self) { + Notification not = queue.poll(); + if (not != null) { + not.accept(observer); + } - } - })); + // decrement count and if we still have work to do + // recursively schedule ourselves to process again + if (counter.decrementAndGet() > 0) { + self.call(); + } + } + })); + } } } } diff --git a/rxjava-core/src/test/java/rx/ErrorHandlingTests.java b/rxjava-core/src/test/java/rx/ErrorHandlingTests.java new file mode 100644 index 0000000000..baaddd0af3 --- /dev/null +++ b/rxjava-core/src/test/java/rx/ErrorHandlingTests.java @@ -0,0 +1,98 @@ +/** + * 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 org.junit.Assert.*; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +import org.junit.Test; + +import rx.schedulers.Schedulers; + +public class ErrorHandlingTests { + + /** + * Test that an error from a user provided Observer.onNext is handled and emitted to the onError + */ + @Test + public void testOnNextError() throws InterruptedException { + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference caughtError = new AtomicReference(); + Observable o = Observable.interval(50, TimeUnit.MILLISECONDS); + Observer observer = new Observer() { + + @Override + public void onCompleted() { + System.out.println("completed"); + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + System.out.println("error: " + e); + caughtError.set(e); + latch.countDown(); + } + + @Override + public void onNext(Long args) { + throw new RuntimeException("forced failure"); + } + }; + o.subscribe(observer); + + latch.await(2000, TimeUnit.MILLISECONDS); + assertNotNull(caughtError.get()); + } + + /** + * Test that an error from a user provided Observer.onNext is handled and emitted to the onError + * even when done across thread boundaries with observeOn + */ + @Test + public void testOnNextErrorAcrossThread() throws InterruptedException { + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference caughtError = new AtomicReference(); + Observable o = Observable.interval(50, TimeUnit.MILLISECONDS); + Observer observer = new Observer() { + + @Override + public void onCompleted() { + System.out.println("completed"); + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + System.out.println("error: " + e); + caughtError.set(e); + latch.countDown(); + } + + @Override + public void onNext(Long args) { + throw new RuntimeException("forced failure"); + } + }; + o.observeOn(Schedulers.newThread()).subscribe(observer); + + latch.await(2000, TimeUnit.MILLISECONDS); + assertNotNull(caughtError.get()); + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java index 69fa6b1718..554b583247 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java @@ -32,6 +32,7 @@ import rx.Observer; import rx.schedulers.Schedulers; import rx.schedulers.TestScheduler; +import rx.util.functions.Action0; import rx.util.functions.Action1; public class OperationObserveOnTest { @@ -88,55 +89,59 @@ public Void answer(InvocationOnMock invocation) throws Throwable { @Test @SuppressWarnings("unchecked") public void testThreadName() throws InterruptedException { + System.out.println("Main Thread: " + Thread.currentThread().getName()); Observable obs = Observable.from("one", null, "two", "three", "four"); Observer observer = mock(Observer.class); - - InOrder inOrder = inOrder(observer); + final String parentThreadName = Thread.currentThread().getName(); final CountDownLatch completedLatch = new CountDownLatch(1); - doAnswer(new Answer() { - - @Override - public Void answer(InvocationOnMock invocation) throws Throwable { - completedLatch.countDown(); - return null; - } - }).when(observer).onCompleted(); - - doAnswer(new Answer() { + // assert subscribe is on main thread + obs = obs.doOnEach(new Action1() { @Override - public Void answer(InvocationOnMock invocation) throws Throwable { - completedLatch.countDown(); - - return null; + public void call(String s) { + String threadName = Thread.currentThread().getName(); + System.out.println("Source ThreadName: " + threadName + " Expected => " + parentThreadName); + assertEquals(parentThreadName, threadName); } - }).when(observer).onError(any(Exception.class)); + }); + + // assert observe is on new thread obs.observeOn(Schedulers.newThread()).doOnEach(new Action1() { @Override public void call(String t1) { String threadName = Thread.currentThread().getName(); boolean correctThreadName = threadName.startsWith("RxNewThreadScheduler"); - System.out.println("ThreadName: " + threadName + " Correct => " + correctThreadName); + System.out.println("ObserveOn ThreadName: " + threadName + " Correct => " + correctThreadName); assertTrue(correctThreadName); } + }).finallyDo(new Action0() { + + @Override + public void call() { + completedLatch.countDown(); + + } }).subscribe(observer); if (!completedLatch.await(1000, TimeUnit.MILLISECONDS)) { fail("timed out waiting"); } - inOrder.verify(observer, times(1)).onCompleted(); + verify(observer, never()).onError(any(Throwable.class)); + verify(observer, times(5)).onNext(any(String.class)); + verify(observer, times(1)).onCompleted(); } + @Test public void observeOnTheSameSchedulerTwice() { TestScheduler scheduler = new TestScheduler(); - + Observable o = Observable.from(1, 2, 3); Observable o2 = o.observeOn(scheduler); @@ -144,15 +149,15 @@ public void observeOnTheSameSchedulerTwice() { Observer observer1 = mock(Observer.class); @SuppressWarnings("unchecked") Observer observer2 = mock(Observer.class); - + InOrder inOrder1 = inOrder(observer1); InOrder inOrder2 = inOrder(observer2); - + o2.subscribe(observer1); o2.subscribe(observer2); - + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); - + inOrder1.verify(observer1, times(1)).onNext(1); inOrder1.verify(observer1, times(1)).onNext(2); inOrder1.verify(observer1, times(1)).onNext(3); @@ -168,11 +173,12 @@ public void observeOnTheSameSchedulerTwice() { inOrder2.verifyNoMoreInteractions(); } + @Test public void observeSameOnMultipleSchedulers() { TestScheduler scheduler1 = new TestScheduler(); TestScheduler scheduler2 = new TestScheduler(); - + Observable o = Observable.from(1, 2, 3); Observable o1 = o.observeOn(scheduler1); Observable o2 = o.observeOn(scheduler2); @@ -181,16 +187,16 @@ public void observeSameOnMultipleSchedulers() { Observer observer1 = mock(Observer.class); @SuppressWarnings("unchecked") Observer observer2 = mock(Observer.class); - + InOrder inOrder1 = inOrder(observer1); InOrder inOrder2 = inOrder(observer2); - + o1.subscribe(observer1); o2.subscribe(observer2); - + scheduler1.advanceTimeBy(1, TimeUnit.SECONDS); scheduler2.advanceTimeBy(1, TimeUnit.SECONDS); - + inOrder1.verify(observer1, times(1)).onNext(1); inOrder1.verify(observer1, times(1)).onNext(2); inOrder1.verify(observer1, times(1)).onNext(3); From 3ec9ef3e6ad5996fad67aa04dca5df8a3521ccd0 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Thu, 12 Dec 2013 23:41:07 -0800 Subject: [PATCH 089/441] UnitTest to assert thread safety of Executor Scheduler - The Executor thread-pools hop threads when using observeOn so this tests that it is thread-safe when doing so. - The test performs non-thread-safe mutations which should fail (or at least be non-deterministic) if memory visibility problems or concurrency is occurring. --- .../rx/schedulers/ExecutorSchedulerTests.java | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java new file mode 100644 index 0000000000..a4f306e436 --- /dev/null +++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.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.schedulers; + +import static org.junit.Assert.*; + +import java.util.HashMap; +import java.util.concurrent.CountDownLatch; + +import org.junit.Test; + +import rx.Scheduler; +import rx.Subscription; +import rx.util.functions.Action0; +import rx.util.functions.Action1; +import rx.util.functions.Func2; + +public class ExecutorSchedulerTests { + + @Test + public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() { + + final int NUM = 1000000; + final CountDownLatch latch = new CountDownLatch(1); + HashMap statefulMap = new HashMap(); + Schedulers.threadPoolForComputation().schedule(statefulMap, + new Func2, Subscription>() { + + @Override + public Subscription call(Scheduler innerScheduler, final HashMap statefulMap) { + return innerScheduler.schedule(new Action1() { + + int nonThreadSafeCounter = 0; + + @Override + public void call(Action0 self) { + Integer i = statefulMap.get("a"); + if (i == null) { + i = 1; + statefulMap.put("a", i); + statefulMap.put("b", i); + } else { + i++; + statefulMap.put("a", i); + statefulMap.put("b", i); + } + nonThreadSafeCounter++; + statefulMap.put("nonThreadSafeCounter", nonThreadSafeCounter); + if (i < NUM) { + self.call(); + } else { + latch.countDown(); + } + } + }); + } + }); + + try { + latch.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + System.out.println("Count A: " + statefulMap.get("a")); + System.out.println("Count B: " + statefulMap.get("b")); + System.out.println("nonThreadSafeCounter: " + statefulMap.get("nonThreadSafeCounter")); + + assertEquals(NUM, statefulMap.get("a").intValue()); + assertEquals(NUM, statefulMap.get("b").intValue()); + assertEquals(NUM, statefulMap.get("nonThreadSafeCounter").intValue()); + } +} From 728f183cea9bc6aae80e0874e7e01211a6a8c3df Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 12 Dec 2013 12:05:02 -0800 Subject: [PATCH 090/441] Removed local SerialSubscription isUnsubscribed implementation since underlying subscription now implements it. --- .../subscriptions/SerialSubscription.scala | 20 +++++++------------ 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala index dfb51cedac..d845b7e5cd 100644 --- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala +++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala @@ -35,21 +35,15 @@ object SerialSubscription { /** * Represents a [[rx.lang.scala.Subscription]] that can be checked for status. */ -class SerialSubscription private[scala] (serial: rx.subscriptions.SerialSubscription) extends Subscription { +class SerialSubscription private[scala] (override val asJavaSubscription: rx.subscriptions.SerialSubscription) extends Subscription { - /* - * As long as rx.subscriptions.SerialSubscription has no isUnsubscribed, - * we need to intercept and do it ourselves. - */ - override val asJavaSubscription: rx.subscriptions.SerialSubscription = new rx.subscriptions.SerialSubscription() { - override def unsubscribe(): Unit = { - if(unsubscribed.compareAndSet(false, true)) { serial.unsubscribe() } - } - override def setSubscription(subscription: rx.Subscription): Unit = serial.setSubscription(subscription) - override def getSubscription(): rx.Subscription = serial.getSubscription() - } + override def unsubscribe(): Unit = asJavaSubscription.unsubscribe() + override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed - def subscription_=(value: Subscription): this.type = { asJavaSubscription.setSubscription(value.asJavaSubscription); this } + def subscription_=(value: Subscription): this.type = { + asJavaSubscription.setSubscription(value.asJavaSubscription) + this + } def subscription: Subscription = Subscription(asJavaSubscription.getSubscription) } From d7997fb7eb2d9f20891985007331ba8a7f45e467 Mon Sep 17 00:00:00 2001 From: headinthebox Date: Thu, 12 Dec 2013 23:42:43 -0800 Subject: [PATCH 091/441] Observable.from with scheduler --- rxjava-core/src/main/java/rx/Observable.java | 40 ++++++++++++----- .../OperationToObservableIterable.java | 44 ++++++++++++++----- .../test/java/rx/ObservableWindowTests.java | 17 ++++++- .../rx/operators/OperationWindowTest.java | 26 +++++------ 4 files changed, 91 insertions(+), 36 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 5d98df26b9..ff554a14ed 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -732,7 +732,7 @@ public static Observable error(Throwable exception, Scheduler scheduler) * @see RxJava Wiki: from() */ public static Observable from(Iterable iterable) { - return create(OperationToObservableIterable.toObservableIterable(iterable)); + return from(iterable, Schedulers.currentThread()); } /** @@ -751,7 +751,7 @@ public static Observable from(Iterable iterable) { * @see MSDN: Observable.ToObservable */ public static Observable from(Iterable iterable, Scheduler scheduler) { - return from(iterable).observeOn(scheduler); + return create(OperationToObservableIterable.toObservableIterable(iterable, scheduler)); } /** @@ -764,14 +764,35 @@ public static Observable from(Iterable iterable, Scheduler s * {@link Subscription} is returned, it is not possible to unsubscribe from * the sequence before it completes. * - * @param items the source sequence + * @param items the source array * @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 * @see RxJava Wiki: from() */ public static Observable from(T[] items) { - return create(OperationToObservableIterable.toObservableIterable(Arrays.asList(items))); + return from(Arrays.asList(items)); + } + + /** + * Converts an Array into an Observable. + *

    + * + *

    + * Note: the entire array is immediately emitted each time an + * {@link Observer} subscribes. Since this occurs before the + * {@link Subscription} is returned, it is not possible to unsubscribe from + * the sequence before it completes. + * + * @param items the source array + * @param scheduler the scheduler to emit the items of the array + * @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 + * @see RxJava Wiki: from() + */ + public static Observable from(T[] items, Scheduler scheduler) { + return from(Arrays.asList(items), scheduler); } /** @@ -828,7 +849,7 @@ public static Observable from(T t1, T t2) { * subscribes. Since this occurs before the {@link Subscription} is * returned, it is not possible to unsubscribe from the sequence before it * completes. - * + * * @param t1 first item * @param t2 second item * @param t3 third item @@ -1074,7 +1095,7 @@ public static Observable range(int start, int count) { * @see Observable.Range Method (Int32, Int32, IScheduler) */ public static Observable range(int start, int count, Scheduler scheduler) { - return range(start, count).observeOn(scheduler); + return from(Range.createWithCount(start, count), scheduler); } /** @@ -1121,10 +1142,7 @@ public static Observable defer(Func0> o * @see RxJava Wiki: just() */ public static Observable just(T value) { - List list = new ArrayList(); - list.add(value); - - return from(list); + return from(Arrays.asList((value))); } /** @@ -1143,7 +1161,7 @@ public static Observable just(T value) { * @see RxJava Wiki: just() */ public static Observable just(T value, Scheduler scheduler) { - return just(value).observeOn(scheduler); + return from(Arrays.asList((value)), scheduler); } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java index a8a970bdd8..4297af00ae 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java +++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java @@ -17,8 +17,14 @@ import rx.Observable.OnSubscribeFunc; import rx.Observer; +import rx.Scheduler; import rx.Subscription; +import rx.schedulers.Schedulers; import rx.subscriptions.Subscriptions; +import rx.util.functions.Action0; +import rx.util.functions.Action1; + +import java.util.Iterator; /** * Converts an Iterable sequence into an Observable. @@ -30,24 +36,42 @@ */ public final class OperationToObservableIterable { + public static OnSubscribeFunc toObservableIterable(Iterable list, Scheduler scheduler) { + return new ToObservableIterable(list, scheduler); + } + public static OnSubscribeFunc toObservableIterable(Iterable list) { - return new ToObservableIterable(list); + return toObservableIterable(list, Schedulers.currentThread()); } private static class ToObservableIterable implements OnSubscribeFunc { - public ToObservableIterable(Iterable list) { + + public ToObservableIterable(Iterable list, Scheduler scheduler) { this.iterable = list; + this.scheduler = scheduler; } - public Iterable iterable; - - public Subscription onSubscribe(Observer observer) { - for (T item : iterable) { - observer.onNext(item); - } - observer.onCompleted(); + Scheduler scheduler; + final Iterable iterable; - return Subscriptions.empty(); + public Subscription onSubscribe(final Observer observer) { + final Iterator iterator = iterable.iterator(); + return scheduler.schedule(new Action1() { + @Override + public void call(Action0 self) { + try { + if (iterator.hasNext()) { + T x = iterator.next(); + observer.onNext(x); + self.call(); + } else { + observer.onCompleted(); + } + } catch (Exception e) { + observer.onError(e); + } + } + }); } } } diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java index 987ce255c9..1133833e0c 100644 --- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java +++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java @@ -30,6 +30,7 @@ public class ObservableWindowTests { @Test public void testWindow() { final ArrayList> lists = new ArrayList>(); + /* Observable.from(1, 2, 3, 4, 5, 6) .window(3).map(new Func1, List>() { @@ -45,8 +46,22 @@ public void call(List t) { lists.add(t); } }); + */ - assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[] { 1, 2, 3 }); + Observable.concat(Observable.from(1, 2, 3, 4, 5, 6).window(3).map(new Func1, Observable>>() { + @Override + public Observable> call(Observable xs) { + return xs.toList(); + } + })).toBlockingObservable().forEach(new Action1>() { + + @Override + public void call(List xs) { + lists.add(xs); + } + }); + + assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[]{1, 2, 3}); assertArrayEquals(lists.get(1).toArray(new Integer[3]), new Integer[] { 4, 5, 6 }); assertEquals(2, lists.size()); diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java index 180179a902..aeaa7d5103 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java @@ -28,6 +28,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; +import rx.schedulers.Schedulers; import rx.schedulers.TestScheduler; import rx.subscriptions.Subscriptions; import rx.util.functions.Action0; @@ -44,21 +45,18 @@ public void before() { scheduler = new TestScheduler(); } - private static List> toLists(Observable> observable) { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + private static List> toLists(Observable> observables) { - observable.subscribe(new Action1>() { + final List> lists = new ArrayList>(); + Observable.concat(observables.map(new Func1, Observable>>() { @Override - public void call(Observable tObservable) { - tObservable.subscribe(new Action1() { - @Override - public void call(T t) { - list.add(t); - } - }); - lists.add(new ArrayList(list)); - list.clear(); + public Observable> call(Observable xs) { + return xs.toList(); + } + })).toBlockingObservable().forEach(new Action1>() { + @Override + public void call(List xs) { + lists.add(xs); } }); return lists; @@ -90,7 +88,7 @@ public void testSkipAndCountGaplessEindows() { @Test public void testOverlappingWindows() { - Observable subject = Observable.from("zero", "one", "two", "three", "four", "five"); + Observable subject = Observable.from(new String[]{"zero", "one", "two", "three", "four", "five"}, Schedulers.currentThread()); Observable> windowed = Observable.create(window(subject, 3, 1)); List> windows = toLists(windowed); From 3921da74db8589db473c33e11d411ed72218403a Mon Sep 17 00:00:00 2001 From: headinthebox Date: Fri, 13 Dec 2013 00:57:02 -0800 Subject: [PATCH 092/441] Observable.from with scheduler Fixed blocking test in ObservableWindowTest --- rxjava-core/src/main/java/rx/Observable.java | 10 ---------- .../src/test/java/rx/ObservableWindowTests.java | 17 ----------------- 2 files changed, 27 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index ff554a14ed..d117ce7d49 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -1034,11 +1034,6 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T *

    * *

    - * Note: the items will be immediately emitted each time an {@link Observer} - * subscribes. Since this occurs before the {@link Subscription} is - * returned, it is not possible to unsubscribe from the sequence before it - * completes. - * * @param t1 first item * @param t2 second item * @param t3 third item @@ -1066,11 +1061,6 @@ public static Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T *

    * *

    - * Note: the entire range is immediately emitted each time an - * {@link Observer} subscribes. Since this occurs before the - * {@link Subscription} is returned, it is 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 diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java index 1133833e0c..855e108312 100644 --- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java +++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java @@ -30,23 +30,6 @@ public class ObservableWindowTests { @Test public void testWindow() { final ArrayList> lists = new ArrayList>(); - /* - Observable.from(1, 2, 3, 4, 5, 6) - .window(3).map(new Func1, List>() { - - @Override - public List call(Observable o) { - return o.toList().toBlockingObservable().single(); - } - - }).toBlockingObservable().forEach(new Action1>() { - - @Override - public void call(List t) { - lists.add(t); - } - }); - */ Observable.concat(Observable.from(1, 2, 3, 4, 5, 6).window(3).map(new Func1, Observable>>() { @Override From 04a9e05ee249457bf4e37fb2d0dd34e02a289e5e Mon Sep 17 00:00:00 2001 From: akarnokd Date: Mon, 16 Dec 2013 11:00:22 +0100 Subject: [PATCH 093/441] Added: BO.Latest, fixed: BO.next, BO.mostRecent, BO.toIterable --- .../rx/observables/BlockingObservable.java | 19 ++ .../java/rx/operators/OperationLatest.java | 184 ++++++++++++++++++ .../rx/operators/OperationMostRecent.java | 12 +- .../main/java/rx/operators/OperationNext.java | 13 +- .../rx/operators/OperationToIterator.java | 20 +- .../observables/BlockingObservableTest.java | 54 +++++ .../rx/operators/OperationLatestTest.java | 162 +++++++++++++++ .../rx/operators/OperationMostRecentTest.java | 30 +++ .../java/rx/operators/OperationNextTest.java | 24 +++ 9 files changed, 495 insertions(+), 23 deletions(-) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationLatest.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationLatestTest.java diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java index 8fe13c9e88..74cc4bbed8 100644 --- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java +++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java @@ -23,6 +23,7 @@ import rx.Observable; import rx.Observer; import rx.Subscription; +import rx.operators.OperationLatest; import rx.operators.OperationMostRecent; import rx.operators.OperationNext; import rx.operators.OperationToFuture; @@ -266,6 +267,24 @@ public Iterable next() { return OperationNext.next(o); } + /** + * Returns the latest item emitted by the underlying Observable, waiting if necessary + * for one to become available. + *

    + * If the underlying observable produces items faster than the Iterator.next() takes them + * onNext events might be skipped, but onError or onCompleted events are not. + *

    + * The difference between BlockingObservable.next() and BlockingObservable.latest() is that + * the former does not overwrite untaken values whereas the latter does. + *

    + * Note also that an onNext() directly followed by onCompleted() might hide the given onNext() event. + * + * @return the Iterable sequence + */ + public Iterable latest() { + return OperationLatest.latest(o); + } + /** * If the {@link Observable} completes after emitting a single item, return that item, * otherwise throw an exception. diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/OperationLatest.java new file mode 100644 index 0000000000..57f0cafce0 --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java @@ -0,0 +1,184 @@ +/** + * 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 java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.concurrent.Semaphore; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import rx.Notification; +import rx.Observable; +import rx.Observer; +import rx.util.Exceptions; + +/** + * Wait for and iterate over the latest values of the source observable. + * If the source works faster than the iterator, values may be skipped, but + * not the onError or onCompleted events. + */ +public final class OperationLatest { + /** Utility class. */ + private OperationLatest() { throw new IllegalStateException("No instances!"); } + + public static Iterable latest(final Observable source) { + return new Iterable() { + @Override + public Iterator iterator() { + LatestObserverIterator lio = new LatestObserverIterator(); + source.subscribe(lio); + return lio; + } + }; + } + + /** Observer of source, iterator for output. */ + static final class LatestObserverIterator implements Observer, Iterator { + final Lock lock = new ReentrantLock(); + final Semaphore notify = new Semaphore(0); + // observer's values + boolean oHasValue; + Notification.Kind oKind; + T oValue; + Throwable oError; + @Override + public void onNext(T args) { + boolean wasntAvailable; + lock.lock(); + try { + wasntAvailable = !oHasValue; + oHasValue = true; + oValue = args; + oKind = Notification.Kind.OnNext; + } finally { + lock.unlock(); + } + if (wasntAvailable) { + notify.release(); + } + } + + @Override + public void onError(Throwable e) { + boolean wasntAvailable; + lock.lock(); + try { + wasntAvailable = !oHasValue; + oHasValue = true; + oValue = null; + oError = e; + oKind = Notification.Kind.OnError; + } finally { + lock.unlock(); + } + if (wasntAvailable) { + notify.release(); + } + } + + @Override + public void onCompleted() { + boolean wasntAvailable; + lock.lock(); + try { + wasntAvailable = !oHasValue; + oHasValue = true; + oValue = null; + oKind = Notification.Kind.OnCompleted; + } finally { + lock.unlock(); + } + if (wasntAvailable) { + notify.release(); + } + } + + // iterator's values + + boolean iDone; + boolean iHasValue; + T iValue; + Throwable iError; + Notification.Kind iKind; + + @Override + public boolean hasNext() { + if (iError != null) { + Exceptions.propagate(iError); + } + if (!iDone) { + if (!iHasValue) { + try { + notify.acquire(); + } catch (InterruptedException ex) { + iError = ex; + iHasValue = true; + iKind = Notification.Kind.OnError; + return true; + } + + lock.lock(); + try { + iKind = oKind; + switch (oKind) { + case OnNext: + iValue = oValue; + oValue = null; // handover + break; + case OnError: + iError = oError; + oError = null; // handover + if (iError != null) { + Exceptions.propagate(iError); + } + break; + case OnCompleted: + iDone = true; + break; + } + oHasValue = false; + } finally { + lock.unlock(); + } + iHasValue = true; + } + } + return !iDone; + } + + @Override + public T next() { + if (iKind == Notification.Kind.OnError) { + Exceptions.propagate(iError); + } + if (hasNext()) { + if (iKind == Notification.Kind.OnNext) { + T v = iValue; + iValue = null; // handover + iHasValue = false; + return v; + } + } + throw new NoSuchElementException(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Read-only iterator."); + } + + } +} diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java index 15406aeece..4e90d3e543 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java @@ -31,16 +31,16 @@ */ public final class OperationMostRecent { - public static Iterable mostRecent(final Observable source, T initialValue) { - - MostRecentObserver mostRecentObserver = new MostRecentObserver(initialValue); - final MostRecentIterator nextIterator = new MostRecentIterator(mostRecentObserver); - - source.subscribe(mostRecentObserver); + public static Iterable mostRecent(final Observable source, final T initialValue) { return new Iterable() { @Override public Iterator iterator() { + MostRecentObserver mostRecentObserver = new MostRecentObserver(initialValue); + final MostRecentIterator nextIterator = new MostRecentIterator(mostRecentObserver); + + source.subscribe(mostRecentObserver); + return nextIterator; } }; diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java index 4f5e9dfd31..82e6587b20 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationNext.java +++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java @@ -34,19 +34,18 @@ public final class OperationNext { public static Iterable next(final Observable items) { - - NextObserver nextObserver = new NextObserver(); - final NextIterator nextIterator = new NextIterator(nextObserver); - - items.materialize().subscribe(nextObserver); - return new Iterable() { @Override public Iterator iterator() { + NextObserver nextObserver = new NextObserver(); + final NextIterator nextIterator = new NextIterator(nextObserver); + + items.materialize().subscribe(nextObserver); + return nextIterator; } }; - + } private static class NextIterator implements Iterator { diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java index 2fcd51872e..9760805fdc 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java +++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java @@ -16,6 +16,7 @@ package rx.operators; import java.util.Iterator; +import java.util.NoSuchElementException; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; @@ -63,27 +64,26 @@ public void onNext(Notification args) { return new Iterator() { private Notification buf; - + @Override public boolean hasNext() { if (buf == null) { buf = take(); } + if (buf.isOnError()) { + throw Exceptions.propagate(buf.getThrowable()); + } return !buf.isOnCompleted(); } @Override public T next() { - if (buf == null) { - buf = take(); + if (hasNext()) { + T result = buf.getValue(); + buf = null; + return result; } - if (buf.isOnError()) { - throw Exceptions.propagate(buf.getThrowable()); - } - - T result = buf.getValue(); - buf = null; - return result; + throw new NoSuchElementException(); } private Notification take() { diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java index f3e05189c1..008aedc6dd 100644 --- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java +++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java @@ -18,6 +18,8 @@ import static org.junit.Assert.*; import java.util.Iterator; +import java.util.NoSuchElementException; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -201,6 +203,58 @@ public void testToIterable() { assertEquals(false, it.hasNext()); } + @Test(expected = NoSuchElementException.class) + public void testToIterableNextOnly() { + BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3)); + + Iterator it = obs.toIterable().iterator(); + + Assert.assertEquals((Integer)1, it.next()); + Assert.assertEquals((Integer)2, it.next()); + Assert.assertEquals((Integer)3, it.next()); + + it.next(); + } + + @Test(expected = NoSuchElementException.class) + public void testToIterableNextOnlyTwice() { + BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3)); + + Iterator it = obs.toIterable().iterator(); + + Assert.assertEquals((Integer)1, it.next()); + Assert.assertEquals((Integer)2, it.next()); + Assert.assertEquals((Integer)3, it.next()); + + boolean exc = false; + try { + it.next(); + } catch (NoSuchElementException ex) { + exc = true; + } + Assert.assertEquals(true, exc); + + it.next(); + } + + @Test + public void testToIterableManyTimes() { + BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3)); + + Iterable iter = obs.toIterable(); + + for (int j = 0; j < 3; j++) { + Iterator it = iter.iterator(); + + Assert.assertTrue(it.hasNext()); + Assert.assertEquals((Integer)1, it.next()); + Assert.assertTrue(it.hasNext()); + Assert.assertEquals((Integer)2, it.next()); + Assert.assertTrue(it.hasNext()); + Assert.assertEquals((Integer)3, it.next()); + Assert.assertFalse(it.hasNext()); + } + } @Test(expected = TestException.class) public void testToIterableWithException() { diff --git a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java new file mode 100644 index 0000000000..e7fd9645c0 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java @@ -0,0 +1,162 @@ + /** + * 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 java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.concurrent.TimeUnit; +import junit.framework.Assert; +import org.junit.Test; +import rx.Observable; +import rx.observables.BlockingObservable; +import rx.schedulers.TestScheduler; +import rx.subjects.PublishSubject; + +public class OperationLatestTest { + @Test(timeout = 1000) + public void testSimple() { + TestScheduler scheduler = new TestScheduler(); + + BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable(); + + Iterable iter = source.latest(); + + Iterator it = iter.iterator(); + + // only 9 because take(10) will immediately call onCompleted when receiving the 10th item + // which onCompleted will overwrite the previous value + for (int i = 0; i < 9; i++) { + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + Assert.assertEquals(true, it.hasNext()); + + Assert.assertEquals(Long.valueOf(i), it.next()); + } + + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + Assert.assertEquals(false, it.hasNext()); + } + @Test(timeout = 1000) + public void testSameSourceMultipleIterators() { + TestScheduler scheduler = new TestScheduler(); + + BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable(); + + Iterable iter = source.latest(); + + for (int j = 0; j < 3; j++) { + Iterator it = iter.iterator(); + + // only 9 because take(10) will immediately call onCompleted when receiving the 10th item + // which onCompleted will overwrite the previous value + for (int i = 0; i < 9; i++) { + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + Assert.assertEquals(true, it.hasNext()); + + Assert.assertEquals(Long.valueOf(i), it.next()); + } + + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + Assert.assertEquals(false, it.hasNext()); + } + } + @Test(timeout = 1000, expected = NoSuchElementException.class) + public void testEmpty() { + BlockingObservable source = Observable.empty().toBlockingObservable(); + + Iterable iter = source.latest(); + + Iterator it = iter.iterator(); + + Assert.assertEquals(false, it.hasNext()); + + it.next(); + } + @Test(timeout = 1000, expected = NoSuchElementException.class) + public void testSimpleJustNext() { + TestScheduler scheduler = new TestScheduler(); + + BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable(); + + Iterable iter = source.latest(); + + Iterator it = iter.iterator(); + + // only 9 because take(10) will immediately call onCompleted when receiving the 10th item + // which onCompleted will overwrite the previous value + for (int i = 0; i < 10; i++) { + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + Assert.assertEquals(Long.valueOf(i), it.next()); + } + } + @Test(timeout = 1000, expected = RuntimeException.class) + public void testHasNextThrows() { + TestScheduler scheduler = new TestScheduler(); + + BlockingObservable source = Observable.error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable(); + + Iterable iter = source.latest(); + + Iterator it = iter.iterator(); + + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + it.hasNext(); + } + @Test(timeout = 1000, expected = RuntimeException.class) + public void testNextThrows() { + TestScheduler scheduler = new TestScheduler(); + + BlockingObservable source = Observable.error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable(); + + Iterable iter = source.latest(); + Iterator it = iter.iterator(); + + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + it.next(); + } + @Test(timeout = 1000) + public void testFasterSource() { + PublishSubject source = PublishSubject.create(); + BlockingObservable blocker = source.toBlockingObservable(); + + Iterable iter = blocker.latest(); + Iterator it = iter.iterator(); + + source.onNext(1); + + Assert.assertEquals(Integer.valueOf(1), it.next()); + + source.onNext(2); + source.onNext(3); + + Assert.assertEquals(Integer.valueOf(3), it.next()); + + source.onNext(4); + source.onNext(5); + source.onNext(6); + + Assert.assertEquals(Integer.valueOf(6), it.next()); + + source.onNext(7); + source.onCompleted(); + + Assert.assertEquals(false, it.hasNext()); + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java index d20f79e819..35382273fc 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java @@ -19,8 +19,13 @@ import static rx.operators.OperationMostRecent.*; import java.util.Iterator; +import java.util.concurrent.TimeUnit; +import org.junit.Assert; import org.junit.Test; +import rx.Observable; +import rx.observables.BlockingObservable; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; import rx.subjects.Subject; @@ -71,4 +76,29 @@ public void testMostRecentWithException() { private static class TestException extends RuntimeException { private static final long serialVersionUID = 1L; } + + @Test(timeout = 1000) + public void testSingleSourceManyIterators() { + TestScheduler scheduler = new TestScheduler(); + BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable(); + + Iterable iter = source.mostRecent(-1L); + + for (int j = 0; j < 3; j++) { + Iterator it = iter.iterator(); + + Assert.assertEquals(Long.valueOf(-1), it.next()); + + for (int i = 0; i < 9; i++) { + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + Assert.assertEquals(true, it.hasNext()); + Assert.assertEquals(Long.valueOf(i), it.next()); + } + scheduler.advanceTimeBy(1, TimeUnit.SECONDS); + + Assert.assertEquals(false, it.hasNext()); + } + + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java index 8a5de26d1d..29b9ea3383 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java @@ -24,13 +24,16 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; +import org.junit.Assert; import org.junit.Test; import rx.Observable; import rx.Observer; import rx.Subscription; +import rx.observables.BlockingObservable; import rx.schedulers.Schedulers; +import rx.schedulers.TestScheduler; import rx.subjects.PublishSubject; import rx.subjects.Subject; import rx.subscriptions.Subscriptions; @@ -293,4 +296,25 @@ public void run() { System.out.println("a: " + a + " b: " + b + " c: " + c); } + @Test(timeout = 2000) + public void testSingleSourceManyIterators() throws InterruptedException { + BlockingObservable source = Observable.interval(50, TimeUnit.MILLISECONDS).take(10).toBlockingObservable(); + + Iterable iter = source.next(); + + for (int j = 0; j < 3; j++) { + Iterator it = iter.iterator(); + + for (int i = 0; i < 9; i++) { + // hasNext has to set the waiting to true, otherwise, all onNext will be skipped + Assert.assertEquals(true, it.hasNext()); + Assert.assertEquals(Long.valueOf(i), it.next()); + } + + Thread.sleep(100); + + Assert.assertEquals(false, it.hasNext()); + } + + } } From e85c4045e340c0573550894b8865b043b9689487 Mon Sep 17 00:00:00 2001 From: Matt Jacobs Date: Mon, 16 Dec 2013 11:01:03 -0800 Subject: [PATCH 094/441] Properly wired up SynchronizedObserver within MergeDelayError operator --- .../src/main/java/rx/operators/OperationMergeDelayError.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java index d899ca1149..704ea181f1 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java @@ -168,7 +168,7 @@ public Subscription onSubscribe(Observer actualObserver) { /** * Subscribe to the parent Observable to get to the children Observables */ - completeSubscription.add(sequences.subscribe(new ParentObserver(actualObserver))); + completeSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver))); /* return our subscription to allow unsubscribing */ return completeSubscription; From 78c5708deb22de85b2ad4474a4a06fce2f6a2d55 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Tue, 17 Dec 2013 09:38:34 +0100 Subject: [PATCH 095/441] Fixes based on @zsxwing's suggestions. --- .../rx/observables/BlockingObservable.java | 5 +- .../java/rx/operators/OperationLatest.java | 120 ++++-------------- .../rx/operators/OperationLatestTest.java | 2 +- 3 files changed, 27 insertions(+), 100 deletions(-) diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java index 74cc4bbed8..7427c24bdb 100644 --- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java +++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java @@ -274,10 +274,7 @@ public Iterable next() { * If the underlying observable produces items faster than the Iterator.next() takes them * onNext events might be skipped, but onError or onCompleted events are not. *

    - * The difference between BlockingObservable.next() and BlockingObservable.latest() is that - * the former does not overwrite untaken values whereas the latter does. - *

    - * Note also that an onNext() directly followed by onCompleted() might hide the given onNext() event. + * Note also that an onNext() directly followed by onCompleted() might hide the onNext() event. * * @return the Iterable sequence */ diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/OperationLatest.java index 57f0cafce0..556e007a4a 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java +++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java @@ -18,8 +18,7 @@ import java.util.Iterator; import java.util.NoSuchElementException; import java.util.concurrent.Semaphore; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; +import java.util.concurrent.atomic.AtomicReference; import rx.Notification; import rx.Observable; import rx.Observer; @@ -39,33 +38,20 @@ public static Iterable latest(final Observable source) { @Override public Iterator iterator() { LatestObserverIterator lio = new LatestObserverIterator(); - source.subscribe(lio); + source.materialize().subscribe(lio); return lio; } }; } /** Observer of source, iterator for output. */ - static final class LatestObserverIterator implements Observer, Iterator { - final Lock lock = new ReentrantLock(); + static final class LatestObserverIterator implements Observer>, Iterator { final Semaphore notify = new Semaphore(0); - // observer's values - boolean oHasValue; - Notification.Kind oKind; - T oValue; - Throwable oError; + // observer's notification + final AtomicReference> reference = new AtomicReference>(); @Override - public void onNext(T args) { - boolean wasntAvailable; - lock.lock(); - try { - wasntAvailable = !oHasValue; - oHasValue = true; - oValue = args; - oKind = Notification.Kind.OnNext; - } finally { - lock.unlock(); - } + public void onNext(Notification args) { + boolean wasntAvailable = reference.getAndSet(args) == null; if (wasntAvailable) { notify.release(); } @@ -73,102 +59,46 @@ public void onNext(T args) { @Override public void onError(Throwable e) { - boolean wasntAvailable; - lock.lock(); - try { - wasntAvailable = !oHasValue; - oHasValue = true; - oValue = null; - oError = e; - oKind = Notification.Kind.OnError; - } finally { - lock.unlock(); - } - if (wasntAvailable) { - notify.release(); - } + // not expected } @Override public void onCompleted() { - boolean wasntAvailable; - lock.lock(); - try { - wasntAvailable = !oHasValue; - oHasValue = true; - oValue = null; - oKind = Notification.Kind.OnCompleted; - } finally { - lock.unlock(); - } - if (wasntAvailable) { - notify.release(); - } + // not expected } - // iterator's values - - boolean iDone; - boolean iHasValue; - T iValue; - Throwable iError; - Notification.Kind iKind; - + // iterator's notification + Notification iNotif; @Override public boolean hasNext() { - if (iError != null) { - Exceptions.propagate(iError); + if (iNotif != null && iNotif.isOnError()) { + throw Exceptions.propagate(iNotif.getThrowable()); } - if (!iDone) { - if (!iHasValue) { + if (iNotif == null || !iNotif.isOnCompleted()) { + if (iNotif == null) { try { notify.acquire(); } catch (InterruptedException ex) { - iError = ex; - iHasValue = true; - iKind = Notification.Kind.OnError; - return true; + Thread.currentThread().interrupt(); + iNotif = new Notification(ex); + throw Exceptions.propagate(ex); } - lock.lock(); - try { - iKind = oKind; - switch (oKind) { - case OnNext: - iValue = oValue; - oValue = null; // handover - break; - case OnError: - iError = oError; - oError = null; // handover - if (iError != null) { - Exceptions.propagate(iError); - } - break; - case OnCompleted: - iDone = true; - break; - } - oHasValue = false; - } finally { - lock.unlock(); + iNotif = reference.getAndSet(null); + if (iNotif.isOnError()) { + throw Exceptions.propagate(iNotif.getThrowable()); } - iHasValue = true; } } - return !iDone; + return !iNotif.isOnCompleted(); } @Override public T next() { - if (iKind == Notification.Kind.OnError) { - Exceptions.propagate(iError); - } if (hasNext()) { - if (iKind == Notification.Kind.OnNext) { - T v = iValue; - iValue = null; // handover - iHasValue = false; + if (iNotif.isOnNext()) { + T v = iNotif.getValue(); + iNotif = null; return v; } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java index e7fd9645c0..3dde8610f9 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java @@ -104,7 +104,7 @@ public void testSimpleJustNext() { Assert.assertEquals(Long.valueOf(i), it.next()); } } - @Test(timeout = 1000, expected = RuntimeException.class) + @Test(/*timeout = 1000, */expected = RuntimeException.class) public void testHasNextThrows() { TestScheduler scheduler = new TestScheduler(); From c11900ca9443f3ad4d1d93bb764d49b55e88c682 Mon Sep 17 00:00:00 2001 From: akarnokd Date: Tue, 17 Dec 2013 10:06:23 +0100 Subject: [PATCH 096/441] Increased time delay in test. --- .../src/test/java/rx/operators/OperationNextTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java index 29b9ea3383..acbf5ed52e 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java @@ -296,9 +296,9 @@ public void run() { System.out.println("a: " + a + " b: " + b + " c: " + c); } - @Test(timeout = 2000) + @Test(timeout = 8000) public void testSingleSourceManyIterators() throws InterruptedException { - BlockingObservable source = Observable.interval(50, TimeUnit.MILLISECONDS).take(10).toBlockingObservable(); + BlockingObservable source = Observable.interval(200, TimeUnit.MILLISECONDS).take(10).toBlockingObservable(); Iterable iter = source.next(); @@ -311,7 +311,7 @@ public void testSingleSourceManyIterators() throws InterruptedException { Assert.assertEquals(Long.valueOf(i), it.next()); } - Thread.sleep(100); + Thread.sleep(400); Assert.assertEquals(false, it.hasNext()); } From 05d12682a39c9df36595cef86fdaf35d10103909 Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 17 Dec 2013 09:31:12 -0800 Subject: [PATCH 097/441] Make NewThreadScheduler create Daemon threads This matches the behavior of Schedulers.COMPUTATION_EXECUTOR and Schedulers.IO_EXECUTOR. See https://groups.google.com/forum/#!topic/rxjava/Qe1qi0aHtnE and https://github.com/Netflix/RxJava/issues/431#issuecomment-30767610 --- .../src/main/java/rx/schedulers/NewThreadScheduler.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java index b2fdff50d2..7e460923a6 100644 --- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java +++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java @@ -52,7 +52,9 @@ private EventLoopScheduler() { @Override public Thread newThread(Runnable r) { - return new Thread(r, "RxNewThreadScheduler-" + count.incrementAndGet()); + Thread t = new Thread(r, "RxNewThreadScheduler-" + count.incrementAndGet()); + t.setDaemon(true); + return t; } }); } From be9841a2925b02e893e48f7ab3e9d04f6964326b Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Tue, 17 Dec 2013 11:42:41 -0800 Subject: [PATCH 098/441] Fix non-deterministic unit test - there is no guarantee for how many threads Interval will use so useless to assert anything on it --- .../operators/OperationParallelMergeTest.java | 30 +++++-------------- 1 file changed, 7 insertions(+), 23 deletions(-) diff --git a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java index 907993ef10..7872ae59d5 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java @@ -58,24 +58,8 @@ public void testParallelMerge() { @Test public void testNumberOfThreads() { - final ConcurrentHashMap threads = new ConcurrentHashMap(); - Observable.merge(getStreams()) - .toBlockingObservable().forEach(new Action1() { - - @Override - public void call(String o) { - System.out.println("o: " + o + " Thread: " + Thread.currentThread()); - threads.put(Thread.currentThread().getName(), Thread.currentThread().getName()); - } - }); - - // without injecting anything, the getStream() method uses Interval which runs on a default scheduler - assertEquals(Runtime.getRuntime().availableProcessors(), threads.keySet().size()); - - // clear - threads.clear(); - - // now we parallelMerge into 3 streams and observeOn for each + final ConcurrentHashMap threads = new ConcurrentHashMap(); + // parallelMerge into 3 streams and observeOn for each // we expect 3 threads in the output OperationParallelMerge.parallelMerge(getStreams(), 3) .flatMap(new Func1, Observable>() { @@ -90,8 +74,8 @@ public Observable call(Observable o) { @Override public void call(String o) { - System.out.println("o: " + o + " Thread: " + Thread.currentThread()); - threads.put(Thread.currentThread().getName(), Thread.currentThread().getName()); + System.out.println("o: " + o + " Thread: " + Thread.currentThread().getId()); + threads.put(Thread.currentThread().getId(), Thread.currentThread().getId()); } }); @@ -100,7 +84,7 @@ public void call(String o) { @Test public void testNumberOfThreadsOnScheduledMerge() { - final ConcurrentHashMap threads = new ConcurrentHashMap(); + final ConcurrentHashMap threads = new ConcurrentHashMap(); // now we parallelMerge into 3 streams and observeOn for each // we expect 3 threads in the output @@ -109,8 +93,8 @@ public void testNumberOfThreadsOnScheduledMerge() { @Override public void call(String o) { - System.out.println("o: " + o + " Thread: " + Thread.currentThread()); - threads.put(Thread.currentThread().getName(), Thread.currentThread().getName()); + System.out.println("o: " + o + " Thread: " + Thread.currentThread().getId()); + threads.put(Thread.currentThread().getId(), Thread.currentThread().getId()); } }); From 988b2f62eb6a80207cc4b08d9785b5a55f8924b7 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Wed, 18 Dec 2013 10:36:29 +0800 Subject: [PATCH 099/441] Fixed issue #595 about null in toList operator --- .../rx/operators/OperationToObservableList.java | 11 ++--------- .../rx/operators/OperationToObservableListTest.java | 13 +++++++++++++ 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java index b87a49fdd1..0ec59d71b2 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java +++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java @@ -55,10 +55,9 @@ public ToObservableList(Observable that) { public Subscription onSubscribe(final Observer> observer) { return that.subscribe(new Observer() { - final ConcurrentLinkedQueue list = new ConcurrentLinkedQueue(); + final List list = new ArrayList(); public void onNext(T value) { - // onNext can be concurrently executed so list must be thread-safe list.add(value); } @@ -68,16 +67,10 @@ public void onError(Throwable ex) { public void onCompleted() { try { - // copy from LinkedQueue to List since ConcurrentLinkedQueue does not implement the List interface - ArrayList l = new ArrayList(list.size()); - for (T t : list) { - l.add(t); - } - // benjchristensen => I want to make this list immutable but some clients are sorting this // instead of using toSortedList() and this change breaks them until we migrate their code. // observer.onNext(Collections.unmodifiableList(l)); - observer.onNext(l); + observer.onNext(new ArrayList(list)); observer.onCompleted(); } catch (Throwable e) { onError(e); diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java index 1124ea6211..767c05acfb 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java @@ -66,4 +66,17 @@ public void testListMultipleObservers() { verify(o2, Mockito.never()).onError(any(Throwable.class)); verify(o2, times(1)).onCompleted(); } + + @Test + public void testListWithNullValue() { + Observable w = Observable.from("one", null, "three"); + Observable> observable = Observable.create(toObservableList(w)); + + @SuppressWarnings("unchecked") + Observer> aObserver = mock(Observer.class); + observable.subscribe(aObserver); + verify(aObserver, times(1)).onNext(Arrays.asList("one", null, "three")); + verify(aObserver, Mockito.never()).onError(any(Throwable.class)); + verify(aObserver, times(1)).onCompleted(); + } } From 829f016a6de1816e290ebd3f8a2802eaf22ae37a Mon Sep 17 00:00:00 2001 From: akarnokd Date: Wed, 18 Dec 2013 14:58:58 +0100 Subject: [PATCH 100/441] Operators: switchCase (Case), ifThen (If), doWhile (DoWhile), WhileDo (While) --- rxjava-core/src/main/java/rx/Observable.java | 123 +++++ .../rx/operators/OperationConditionals.java | 242 ++++++++++ .../operators/OperationConditionalsTest.java | 453 ++++++++++++++++++ 3 files changed, 818 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationConditionals.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 5d98df26b9..cf428ce3de 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -41,6 +41,7 @@ import rx.operators.OperationCast; import rx.operators.OperationCombineLatest; import rx.operators.OperationConcat; +import rx.operators.OperationConditionals; import rx.operators.OperationDebounce; import rx.operators.OperationDefaultIfEmpty; import rx.operators.OperationDefer; @@ -1923,6 +1924,128 @@ public static Observable switchOnNext(Observable the case key type + * @param the result value type + * @param caseSelector the function that produces a case key when an Observer subscribes + * @param mapOfCases a map that maps a case key to an observable sequence + * @return an Observable that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to an + * empty observable + */ + public static Observable switchCase(Func0 caseSelector, + Map> mapOfCases) { + return switchCase(caseSelector, mapOfCases, Observable.empty()); + } + + /** + * Return an Observable that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to an + * empty observable which runs on the given scheduler. + * @param the case key type + * @param the result value type + * @param caseSelector the function that produces a case key when an Observer subscribes + * @param mapOfCases a map that maps a case key to an observable sequence + * @param scheduler the scheduler where the empty observable is observed + * @return an Observable that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to an + * empty observable which runs on the given scheduler + */ + public static Observable switchCase(Func0 caseSelector, + Map> mapOfCases, Scheduler scheduler) { + return switchCase(caseSelector, mapOfCases, Observable.empty(scheduler)); + } + /** + * Return an Observable that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to the + * default observable. + * @param the case key type + * @param the result value type + * @param caseSelector the function that produces a case key when an Observer subscribes + * @param mapOfCases a map that maps a case key to an observable sequence + * @param defaultCase the default observable if the {@code mapOfCases} doesn't contain a value for + * the key returned by the {@case caseSelector} + * @return an Observable that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to an + * empty observable + */ + public static Observable switchCase(Func0 caseSelector, + Map> mapOfCases, + Observable defaultCase) { + return create(OperationConditionals.switchCase(caseSelector, mapOfCases, defaultCase)); + } + + /** + * Return an Observable that subscribes to the this Observable, + * then resubscribes only if the postCondition evaluates to true. + * @param postCondition the post condition after the source completes + * @return an Observable that subscribes to the source Observable, + * then resubscribes only if the postCondition evaluates to true. + */ + public Observable doWhile(Func0 postCondition) { + return create(OperationConditionals.doWhile(this, postCondition)); + } + + /** + * Return an Observable that subscribes and resubscribes to this + * Observable if the preCondition evaluates to true. + * @param preCondition the condition to evaluate before subscribing to this, + * and subscribe to source if it returns {@code true} + * @return an Observable that subscribes and resubscribes to the source + * Observable if the preCondition evaluates to true. + */ + public Observable whileDo(Func0 preCondition) { + return create(OperationConditionals.whileDo(this, preCondition)); + } + + /** + * Return an Observable that subscribes to the + * then Observables if the condition function evaluates to true, or to an empty + * Observable if false. + * @param the result value type + * @param condition the condition to decide which Observables to subscribe to + * @param then the Observable sequence to subscribe to if {@code condition} is {@code true} + * @return an Observable that subscribes to the + * then Observables if the condition function evaluates to true, or to an empty + * Observable running on the given scheduler if false + */ + public static Observable ifThen(Func0 condition, Observable then) { + return ifThen(condition, then, Observable.empty()); + } + + /** + * Return an Observable that subscribes to the + * then Observables if the condition function evaluates to true, or to an empty + * Observable running on the given scheduler if false. + * @param the result value type + * @param condition the condition to decide which Observables to subscribe to + * @param then the Observable sequence to subscribe to if {@code condition} is {@code true} + * @param scheduler the scheduler where the empty Observable is observed in case the condition returns false + * @return an Observable that subscribes to the + * then Observables if the condition function evaluates to true, or to an empty + * Observable running on the given scheduler if false + */ + public static Observable ifThen(Func0 condition, Observable then, Scheduler scheduler) { + return ifThen(condition, then, Observable.empty(scheduler)); + } + /** + * Return an Observable that subscribes to either the + * then or orElse Observables depending on a condition function. + * @param the result value type + * @param condition the condition to decide which Observables to subscribe to + * @param then the Observable sequence to subscribe to if {@code condition} is {@code true} + * @param orElse the Observable sequence to subscribe to if {@code condition} is {@code false} + * @return an Observable that subscribes to either the + * then or orElse Observables depending on a condition function + */ + public static Observable ifThen(Func0 condition, Observable then, + Observable orElse) { + return create(OperationConditionals.ifThen(condition, then, orElse)); + } + /** * Accepts an Observable and wraps it in another Observable that ensures * that the resulting Observable is chronologically well-behaved. diff --git a/rxjava-core/src/main/java/rx/operators/OperationConditionals.java b/rxjava-core/src/main/java/rx/operators/OperationConditionals.java new file mode 100644 index 0000000000..06e14e4328 --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationConditionals.java @@ -0,0 +1,242 @@ +/** + * 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 java.util.Map; +import rx.Observable; +import rx.Observable.OnSubscribeFunc; +import rx.Observer; +import rx.Subscription; +import rx.subscriptions.SerialSubscription; +import rx.subscriptions.Subscriptions; +import rx.util.functions.Func0; + +/** + * Implementation of conditional-based operations such as Case, If, DoWhile and While. + */ +public final class OperationConditionals { + /** Utility class. */ + private OperationConditionals() { throw new IllegalStateException("No instances!"); } + /** + * Return a subscription function that subscribes to an observable sequence + * chosen from a map of observables via a selector function or to the + * default observable. + * @param the case key type + * @param the result value type + * @param caseSelector the function that produces a case key when an Observer subscribes + * @param mapOfCases a map that maps a case key to an observable sequence + * @param defaultCase the default observable if the {@code mapOfCases} doesn't contain a value for + * the key returned by the {@case caseSelector} + * @return a subscription function + */ + public static OnSubscribeFunc switchCase( + Func0 caseSelector, + Map> mapOfCases, + Observable defaultCase) { + return new SwitchCase(caseSelector, mapOfCases, defaultCase); + } + /** + * Return a subscription function that subscribes to either the + * then or orElse Observables depending on a condition function. + * @param the result value type + * @param condition the condition to decide which Observables to subscribe to + * @param then the Observable sequence to subscribe to if {@code condition} is {@code true} + * @param orElse the Observable sequence to subscribe to if {@code condition} is {@code false} + * @return a subscription function + */ + public static OnSubscribeFunc ifThen( + Func0 condition, + Observable then, + Observable orElse) { + return new IfThen(condition, then, orElse); + } + /** + * Return a subscription function that subscribes to the source Observable, + * then resubscribes only if the postCondition evaluates to true. + * @param the result value type + * @param source the source Observable + * @param postCondition the post condition after the source completes + * @return a subscription function. + */ + public static OnSubscribeFunc doWhile(Observable source, Func0 postCondition) { + return new WhileDoWhile(source, TRUE, postCondition); + } + /** + * Return a subscription function that subscribes and resubscribes to the source + * Observable if the preCondition evaluates to true. + * @param the result value type + * @param source the source Observable + * @param preCondition the condition to evaluate before subscribing to source, + * and subscribe to source if it returns {@code true} + * @return a subscription function. + */ + public static OnSubscribeFunc whileDo(Observable source, Func0 preCondition) { + return new WhileDoWhile(source, preCondition, preCondition); + } + /** + * Select an observable from a map based on a case key returned by a selector + * function when an observer subscribes. + * @param the case key type + * @param the result value type + */ + private static final class SwitchCase implements OnSubscribeFunc { + final Func0 caseSelector; + final Map> mapOfCases; + final Observable defaultCase; + public SwitchCase(Func0 caseSelector, + Map> mapOfCases, + Observable defaultCase) { + this.caseSelector = caseSelector; + this.mapOfCases = mapOfCases; + this.defaultCase = defaultCase; + } + + @Override + public Subscription onSubscribe(Observer t1) { + Observable target; + try { + K caseKey = caseSelector.call(); + if (mapOfCases.containsKey(caseKey)) { + target = mapOfCases.get(caseKey); + } else { + target = defaultCase; + } + } catch (Throwable t) { + t1.onError(t); + return Subscriptions.empty(); + } + return target.subscribe(t1); + } + } + /** Returns always true. */ + private static final class Func0True implements Func0 { + @Override + public Boolean call() { + return true; + } + } + /** Returns always true function. */ + private static final Func0True TRUE = new Func0True(); + /** + * Given a condition, subscribe to one of the observables when an Observer + * subscribes. + * @param the result value type + */ + private static final class IfThen implements OnSubscribeFunc { + final Func0 condition; + final Observable then; + final Observable orElse; + public IfThen(Func0 condition, Observable then, Observable orElse) { + this.condition = condition; + this.then = then; + this.orElse = orElse; + } + @Override + public Subscription onSubscribe(Observer t1) { + Observable target; + try { + if (condition.call()) { + target = then; + } else { + target = orElse; + } + } catch (Throwable t) { + t1.onError(t); + return Subscriptions.empty(); + } + return target.subscribe(t1); + } + } + /** + * Repeatedly subscribes to the source observable if the pre- or + * postcondition is true. + *

    + * This combines the While and DoWhile into a single operation through + * the conditions. + * @param the result value type + */ + private static final class WhileDoWhile implements OnSubscribeFunc { + final Func0 preCondition; + final Func0 postCondition; + final Observable source; + public WhileDoWhile(Observable source, + Func0 preCondition, Func0 postCondition + ) { + this.source = source; + this.preCondition = preCondition; + this.postCondition = postCondition; + } + + @Override + public Subscription onSubscribe(Observer t1) { + boolean first; + try { + first = preCondition.call(); + } catch (Throwable t) { + t1.onError(t); + return Subscriptions.empty(); + } + if (first) { + SerialSubscription ssub = new SerialSubscription(); + + ssub.setSubscription(source.subscribe(new SourceObserver(t1, ssub))); + + return ssub; + } else { + t1.onCompleted(); + } + return Subscriptions.empty(); + } + /** Observe the source. */ + final class SourceObserver implements Observer { + final SerialSubscription cancel; + final Observer observer; + public SourceObserver(Observer observer, SerialSubscription cancel) { + this.observer = observer; + this.cancel = cancel; + } + + @Override + public void onNext(T args) { + observer.onNext(args); + } + + @Override + public void onError(Throwable e) { + observer.onError(e); + cancel.unsubscribe(); + } + + @Override + public void onCompleted() { + boolean next; + try { + next = postCondition.call(); + } catch (Throwable t) { + observer.onError(t); + return; + } + if (next) { + cancel.setSubscription(source.subscribe(this)); + } else { + observer.onCompleted(); + cancel.unsubscribe(); + } + } + + } + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java b/rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java new file mode 100644 index 0000000000..3daec59297 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java @@ -0,0 +1,453 @@ +/** + * 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 java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mock; +import static org.mockito.Mockito.*; +import org.mockito.MockitoAnnotations; +import rx.Observable; +import rx.Observer; +import rx.Subscription; +import rx.schedulers.Schedulers; +import rx.schedulers.TestScheduler; +import rx.util.functions.Func0; + +public class OperationConditionalsTest { + @Mock + Observer observer; + TestScheduler scheduler; + Func0 func; + Func0 funcError; + Func0 condition; + Func0 conditionError; + int numRecursion = 250; + + @Before + public void before() { + MockitoAnnotations.initMocks(this); + scheduler = new TestScheduler(); + func = new Func0() { + int count = 1; + @Override + public Integer call() { + return count++; + } + }; + funcError = new Func0() { + int count = 1; + @Override + public Integer call() { + if (count == 2) { + throw new RuntimeException("Forced failure!"); + } + return count++; + } + }; + condition = new Func0() { + boolean r; + @Override + public Boolean call() { + r = !r; + return r; + } + + }; + conditionError = new Func0() { + boolean r; + @Override + public Boolean call() { + r = !r; + if (!r) { + throw new RuntimeException("Forced failure!"); + } + return r; + } + + }; + } + Func0 just(final T value) { + return new Func0() { + @Override + public T call() { + return value; + } + }; + } + + @SuppressWarnings("unchecked") + void observe(Observable source, T... values) { + Observer o = mock(Observer.class); + + Subscription s = source.subscribe(o); + + InOrder inOrder = inOrder(o); + + for (T v : values) { + inOrder.verify(o, times(1)).onNext(v); + } + inOrder.verify(o, times(1)).onCompleted(); + verify(o, never()).onError(any(Throwable.class)); + + s.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + + @SuppressWarnings("unchecked") + void observeSequence(Observable source, Iterable values) { + Observer o = mock(Observer.class); + + Subscription s = source.subscribe(o); + + InOrder inOrder = inOrder(o); + + for (T v : values) { + inOrder.verify(o, times(1)).onNext(v); + } + inOrder.verify(o, times(1)).onCompleted(); + verify(o, never()).onError(any(Throwable.class)); + + s.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + + @SuppressWarnings("unchecked") + void observeError(Observable source, Class error, T... valuesBeforeError) { + Observer o = mock(Observer.class); + + Subscription s = source.subscribe(o); + + InOrder inOrder = inOrder(o); + + for (T v : valuesBeforeError) { + inOrder.verify(o, times(1)).onNext(v); + } + inOrder.verify(o, times(1)).onError(any(error)); + verify(o, never()).onCompleted(); + + s.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + + @SuppressWarnings("unchecked") + void observeSequenceError(Observable source, Class error, Iterable valuesBeforeError) { + Observer o = mock(Observer.class); + + Subscription s = source.subscribe(o); + + InOrder inOrder = inOrder(o); + + for (T v : valuesBeforeError) { + inOrder.verify(o, times(1)).onNext(v); + } + inOrder.verify(o, times(1)).onError(any(error)); + verify(o, never()).onCompleted(); + + s.unsubscribe(); + + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSimple() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.from(4, 5, 6); + + Map> map = new HashMap>(); + map.put(1, source1); + map.put(2, source2); + + Observable result = Observable.switchCase(func, map); + + observe(result, 1, 2, 3); + observe(result, 4, 5, 6); + observe(result); + } + @Test + public void testDefaultCase() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.from(4, 5, 6); + + Map> map = new HashMap>(); + map.put(1, source1); + + Observable result = Observable.switchCase(func, map, source2); + + observe(result, 1, 2, 3); + observe(result, 4, 5, 6); + observe(result, 4, 5, 6); + } + @Test + public void testCaseSelectorThrows() { + Observable source1 = Observable.from(1, 2, 3); + + Map> map = new HashMap>(); + map.put(1, source1); + + Observable result = Observable.switchCase(funcError, map); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + @Test + public void testMapGetThrows() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.from(4, 5, 6); + + Map> map = new HashMap>() { + + @Override + public Observable get(Object key) { + if (key.equals(2)) { + throw new RuntimeException("Forced failure!"); + } + return super.get(key); + } + + }; + map.put(1, source1); + map.put(2, source2); + + Observable result = Observable.switchCase(func, map); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + @Test + public void testMapContainsKeyThrows() { + Observable source1 = Observable.from(1, 2, 3); + + Map> map = new HashMap>() { + + @Override + public boolean containsKey(Object key) { + if (key.equals(2)) { + throw new RuntimeException("Forced failure!"); + } + return super.containsKey(key); + } + + }; + map.put(1, source1); + + Observable result = Observable.switchCase(func, map); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + @Test + public void testChosenObservableThrows() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.error(new RuntimeException("Forced failure")); + + Map> map = new HashMap>(); + map.put(1, source1); + map.put(2, source2); + + Observable result = Observable.switchCase(func, map); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + @Test + public void testIfThen() { + Observable source1 = Observable.from(1, 2, 3); + + Observable result = Observable.ifThen(condition, source1); + + observe(result, 1, 2, 3); + observe(result); + observe(result, 1, 2, 3); + observe(result); + } + + @Test + public void testIfThenElse() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.from(4, 5, 6); + + Observable result = Observable.ifThen(condition, source1, source2); + + observe(result, 1, 2, 3); + observe(result, 4, 5, 6); + observe(result, 1, 2, 3); + observe(result, 4, 5, 6); + } + + @Test + public void testIfThenConditonThrows() { + Observable source1 = Observable.from(1, 2, 3); + + Observable result = Observable.ifThen(conditionError, source1); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + + @Test + public void testIfThenObservableThrows() { + Observable source1 = Observable.error(new RuntimeException("Forced failure!")); + + Observable result = Observable.ifThen(condition, source1); + + observeError(result, RuntimeException.class); + observe(result); + + observeError(result, RuntimeException.class); + observe(result); + } + @Test + public void testIfThenElseObservableThrows() { + Observable source1 = Observable.from(1, 2, 3); + Observable source2 = Observable.error(new RuntimeException("Forced failure!")); + + Observable result = Observable.ifThen(condition, source1, source2); + + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + observe(result, 1, 2, 3); + observeError(result, RuntimeException.class); + } + + @Test + public void testDoWhile() { + Observable source1 = Observable.from(1, 2, 3); + + Observable result = source1.doWhile(condition); + + observe(result, 1, 2, 3, 1, 2, 3); + } + @Test + public void testDoWhileOnce() { + Observable source1 = Observable.from(1, 2, 3); + + condition.call(); // toggle to false + Observable result = source1.doWhile(condition); + + observe(result, 1, 2, 3); + } + @Test + public void testDoWhileConditionThrows() { + Observable source1 = Observable.from(1, 2, 3); + Observable result = source1.doWhile(conditionError); + + observeError(result, RuntimeException.class, 1, 2, 3); + } + @Test + public void testDoWhileSourceThrows() { + Observable source1 = Observable.concat(Observable.from(1, 2, 3), + Observable.error(new RuntimeException("Forced failure!"))); + + Observable result = source1.doWhile(condition); + + observeError(result, RuntimeException.class, 1, 2, 3); + } + Func0 countdown(final int n) { + return new Func0() { + int count = n; + @Override + public Boolean call() { + return count-- > 0; + } + }; + } + @Test + public void testDoWhileManyTimes() { + Observable source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread()); + + List expected = new ArrayList(numRecursion * 3); + for (int i = 0; i < numRecursion; i++) { + expected.add(1); + expected.add(2); + expected.add(3); + } + + Observable result = source1.doWhile(countdown(numRecursion)); + + observeSequence(result, expected); + } + @Test + public void testWhileDo() { + Observable source1 = Observable.from(1, 2, 3); + Observable result = source1.whileDo(countdown(2)); + + observe(result, 1, 2, 3, 1, 2, 3); + } + @Test + public void testWhileDoOnce() { + Observable source1 = Observable.from(1, 2, 3); + Observable result = source1.whileDo(countdown(1)); + + observe(result, 1, 2, 3); + } + @Test + public void testWhileDoZeroTimes() { + Observable source1 = Observable.from(1, 2, 3); + Observable result = source1.whileDo(countdown(0)); + + observe(result); + } + @Test + public void testWhileDoManyTimes() { + Observable source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread()); + + List expected = new ArrayList(numRecursion * 3); + for (int i = 0; i < numRecursion; i++) { + expected.add(1); + expected.add(2); + expected.add(3); + } + + Observable result = source1.whileDo(countdown(numRecursion)); + + observeSequence(result, expected); + } + @Test + public void testWhileDoConditionThrows() { + Observable source1 = Observable.from(1, 2, 3); + Observable result = source1.whileDo(conditionError); + + observeError(result, RuntimeException.class, 1, 2, 3); + } + @Test + public void testWhileDoConditionThrowsImmediately() { + Observable source1 = Observable.from(1, 2, 3); + conditionError.call(); + Observable result = source1.whileDo(conditionError); + + observeError(result, RuntimeException.class); + } + @Test + public void testWhileDoSourceThrows() { + Observable source1 = Observable.concat(Observable.from(1, 2, 3), + Observable.error(new RuntimeException("Forced failure!"))); + + Observable result = source1.whileDo(condition); + + observeError(result, RuntimeException.class, 1, 2, 3); + } +} From fa1b0eb36729cfabbd2924b69a90c6f6ecd1f2bb Mon Sep 17 00:00:00 2001 From: akarnokd Date: Wed, 18 Dec 2013 22:47:52 +0100 Subject: [PATCH 101/441] Operators DelaySubscription, TakeLast w/ time, TakeLastBuffer --- rxjava-core/src/main/java/rx/Observable.java | 167 +++++++++++++++++ .../java/rx/operators/OperationDelay.java | 42 +++++ .../java/rx/operators/OperationTakeLast.java | 121 +++++++++++++ .../java/rx/operators/OperationDelayTest.java | 42 +++++ .../rx/operators/OperationTakeLastTest.java | 168 +++++++++++++++++- 5 files changed, 539 insertions(+), 1 deletion(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 5d98df26b9..e328af21fd 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -2123,6 +2123,31 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) { return OperationDelay.delay(this, delay, unit, scheduler); } + /** + * Return an Observable which delays the subscription to this Observable sequence + * by the given amount. + * @param delay the time to delay the subscription + * @param unit the time unit + * @return an Observable which delays the subscription to this Observable sequence + * by the given amount. + */ + public Observable delaySubscription(long delay, TimeUnit unit) { + return delaySubscription(delay, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Return an Observable which delays the subscription to this Observable sequence + * by the given amount, waiting and subscribing on the given scheduler. + * @param delay the time to delay the subscription + * @param unit the time unit + * @param scheduler the scheduler where the waiting and subscription will happen + * @return an Observable which delays the subscription to this Observable sequence + * by the given amount, waiting and subscribing on the given scheduler + */ + public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) { + return create(OperationDelay.delaySubscription(this, delay, unit, scheduler)); + } + /** * Drops items emitted by an Observable that are followed by newer items * before a timeout value expires. The timer resets on each emission. @@ -5289,6 +5314,148 @@ public Observable takeLast(final int count) { return create(OperationTakeLast.takeLast(this, count)); } + /** + * Return an Observable which contains the items from this observable which + * were emitted not before this completed minus a time window. + * + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @return an Observable which contains the items from this observable which + * were emitted not before this completed minus a time window. + */ + public Observable takeLast(long time, TimeUnit unit) { + return takeLast(time, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Return an Observable which contains the items from this observable which + * were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler. + * + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @param scheduler the scheduler which provides the timestamps for the observed + * elements + * @return an Observable which contains the items from this observable which + * were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler + */ + public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) { + return create(OperationTakeLast.takeLast(this, time, unit, scheduler)); + } + + /** + * Return an Observable which contains at most count items from this Observable + * which were emitted not before this completed minus a time window. + * + * @param count the maximum number of items to return + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @return Return an Observable which contains at most count items from this Observable + * which were emitted not before this completed minus a time window. + */ + public Observable takeLast(int count, long time, TimeUnit unit) { + return takeLast(count, time, unit, Schedulers.threadPoolForComputation()); + } + + /** + * Return an Observable which contains at most count items from this Observable + * which were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler. + * + * @param count the maximum number of items to return + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @param scheduler the scheduler which provides the timestamps for the observed + * elements + * @return Return an Observable which contains at most count items from this Observable + * which were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler + */ + public Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) { + if (count < 0) { + throw new IllegalArgumentException("count >= 0 required"); + } + return create(OperationTakeLast.takeLast(this, count, time, unit, scheduler)); + } + + /** + * Return an Observable which emits single List containing the last count + * elements from this Observable. + * + * @param count the number of items to take last + * @return an Observable which emits single list containing the last count + * elements from this Observable. + */ + public Observable> takeLastBuffer(int count) { + return takeLast(count).toList(); + } + + /** + * Return an Observable which emits single List containing items which + * were emitted not before this completed minus a time window. + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @return an Observable which emits single list containing items which + * were emitted not before this completed minus a time window + */ + public Observable> takeLastBuffer(long time, TimeUnit unit) { + return takeLast(time, unit).toList(); + } + + /** + * Return an Observable which emits single List containing items which + * were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler. + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @param scheduler the scheduler which provides the timestamps for the observed + * elements + * @return an Observable which emits single list containing items which + * were emitted not before this completed minus a time window, where the timing + * information is provided by the given scheduler + */ + public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) { + return takeLast(time, unit, scheduler).toList(); + } + + /** + * Return an Observable which emits a single List containing at most count items + * from this Observable which were emitted not before this completed minus a time window. + * @param count the number of items to take last + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @return an Observable which emits a single List containing at most count items + * from this Observable which were emitted not before this completed minus a time window. + */ + public Observable> takeLastBuffer(int count, long time, TimeUnit unit) { + return takeLast(count, time, unit).toList(); + } + + /** + * Return an Observable which emits a single List containing at most count items + * from this Observable which were emitted not before this completed minus a time window. + * @param count the number of items to take last + * @param time the length of the time window, relative to the completion of this + * observable. + * @param unit the time unit + * @param scheduler the scheduler which provides the timestamps for the observed + * elements + * @return an Observable which emits a single List containing at most count items + * from this Observable which were emitted not before this completed minus a time window. + */ + public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) { + return takeLast(count, time, unit, scheduler).toList(); + } + + /** * Returns an Observable that emits the items from the source Observable * only until the other Observable emits an item. diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java index b1f7b088da..4594adda76 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java +++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java @@ -18,8 +18,13 @@ import java.util.concurrent.TimeUnit; import rx.Observable; +import rx.Observable.OnSubscribeFunc; +import rx.Observer; import rx.Scheduler; +import rx.Subscription; import rx.observables.ConnectableObservable; +import rx.subscriptions.SerialSubscription; +import rx.util.functions.Action0; import rx.util.functions.Func1; public final class OperationDelay { @@ -40,4 +45,41 @@ public T call(Long ignored) { }); return Observable.concat(seqs); } + + /** + * Delays the subscription to the source by the given amount, running on the given scheduler. + */ + public static OnSubscribeFunc delaySubscription(Observable source, long time, TimeUnit unit, Scheduler scheduler) { + return new DelaySubscribeFunc(source, time, unit, scheduler); + } + + /** Subscribe function which schedules the actual subscription to source on a scheduler at a later time. */ + private static final class DelaySubscribeFunc implements OnSubscribeFunc { + final Observable source; + final Scheduler scheduler; + final long time; + final TimeUnit unit; + + public DelaySubscribeFunc(Observable source, long time, TimeUnit unit, Scheduler scheduler) { + this.source = source; + this.scheduler = scheduler; + this.time = time; + this.unit = unit; + } + @Override + public Subscription onSubscribe(final Observer t1) { + final SerialSubscription ssub = new SerialSubscription(); + + ssub.setSubscription(scheduler.schedule(new Action0() { + @Override + public void call() { + if (!ssub.isUnsubscribed()) { + ssub.setSubscription(source.subscribe(t1)); + } + } + }, time, unit)); + + return ssub; + } + } } diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java index d324f7ce42..c0558d43e1 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java +++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java @@ -17,12 +17,16 @@ import java.util.Deque; import java.util.LinkedList; +import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; import rx.Observable; import rx.Observable.OnSubscribeFunc; import rx.Observer; +import rx.Scheduler; import rx.Subscription; +import rx.subscriptions.SingleAssignmentSubscription; +import rx.util.Timestamped; /** * Returns an Observable that emits the last count items emitted by the source @@ -119,4 +123,121 @@ public void onNext(T value) { } } + + /** + * Returns the items emitted by source whose arrived in the time window + * before the source completed. + */ + public static OnSubscribeFunc takeLast(Observable source, long time, TimeUnit unit, Scheduler scheduler) { + return new TakeLastTimed(source, -1, time, unit, scheduler); + } + + /** + * Returns the items emitted by source whose arrived in the time window + * before the source completed and at most count values. + */ + public static OnSubscribeFunc takeLast(Observable source, int count, long time, TimeUnit unit, Scheduler scheduler) { + return new TakeLastTimed(source, count, time, unit, scheduler); + } + + /** Take only the values which appeared some time before the completion. */ + static final class TakeLastTimed implements OnSubscribeFunc { + final Observable source; + final long ageMillis; + final Scheduler scheduler; + final int count; + + public TakeLastTimed(Observable source, int count, long time, TimeUnit unit, Scheduler scheduler) { + this.source = source; + this.ageMillis = unit.toMillis(time); + this.scheduler = scheduler; + this.count = count; + } + + @Override + public Subscription onSubscribe(Observer t1) { + SingleAssignmentSubscription sas = new SingleAssignmentSubscription(); + sas.set(source.subscribe(new TakeLastTimedObserver(t1, sas, count, ageMillis, scheduler))); + return sas; + } + } + /** Observes source values and keeps the most recent items. */ + static final class TakeLastTimedObserver implements Observer { + final Observer observer; + final Subscription cancel; + final long ageMillis; + final Scheduler scheduler; + /** -1 indicates unlimited buffer. */ + final int count; + + final Deque> buffer = new LinkedList>(); + + public TakeLastTimedObserver(Observer observer, Subscription cancel, + int count, long ageMillis, Scheduler scheduler) { + this.observer = observer; + this.cancel = cancel; + this.ageMillis = ageMillis; + this.scheduler = scheduler; + this.count = count; + } + + protected void runEvictionPolicy(long now) { + // trim size + while (count >= 0 && buffer.size() > count) { + buffer.pollFirst(); + } + // remove old entries + while (!buffer.isEmpty()) { + Timestamped v = buffer.peekFirst(); + if (v.getTimestampMillis() < now - ageMillis) { + buffer.pollFirst(); + } else { + break; + } + } + } + + @Override + public void onNext(T args) { + long t = scheduler.now(); + buffer.add(new Timestamped(t, args)); + runEvictionPolicy(t); + } + + @Override + public void onError(Throwable e) { + buffer.clear(); + observer.onError(e); + cancel.unsubscribe(); + } + + /** + * Emit the contents of the buffer. + * @return true if no exception was raised in the process + */ + protected boolean emitBuffer() { + for (Timestamped v : buffer) { + try { + observer.onNext(v.getValue()); + } catch (Throwable t) { + buffer.clear(); + observer.onError(t); + return false; + } + } + buffer.clear(); + return true; + } + + @Override + public void onCompleted() { + runEvictionPolicy(scheduler.now()); + + if (emitBuffer()) { + observer.onCompleted(); + } + cancel.unsubscribe(); + } + + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java index 538131731d..10fdd459bd 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java @@ -30,9 +30,11 @@ import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mock; +import static org.mockito.Mockito.mock; import rx.Observable; import rx.Observer; +import rx.Subscription; import rx.schedulers.TestScheduler; import rx.util.functions.Func1; @@ -193,4 +195,44 @@ public void testDelayWithMultipleSubscriptions() { verify(observer, never()).onError(any(Throwable.class)); verify(observer2, never()).onError(any(Throwable.class)); } + + @Test + public void testDelaySubscription() { + TestScheduler scheduler = new TestScheduler(); + + Observable result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler); + + Observer o = mock(Observer.class); + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + inOrder.verify(o, never()).onNext(any()); + inOrder.verify(o, never()).onCompleted(); + + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + inOrder.verify(o, times(1)).onNext(1); + inOrder.verify(o, times(1)).onNext(2); + inOrder.verify(o, times(1)).onNext(3); + inOrder.verify(o, times(1)).onCompleted(); + + verify(o, never()).onError(any(Throwable.class)); + } + @Test + public void testDelaySubscriptionCancelBeforeTime() { + TestScheduler scheduler = new TestScheduler(); + + Observable result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler); + + Observer o = mock(Observer.class); + + Subscription s = result.subscribe(o); + s.unsubscribe(); + scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); + + verify(o, never()).onNext(any()); + verify(o, never()).onCompleted(); + verify(o, never()).onError(any(Throwable.class)); + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java index 5ec876368b..763e3f4c1e 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java @@ -15,7 +15,7 @@ */ package rx.operators; -import static org.mockito.Matchers.*; +import java.util.concurrent.TimeUnit; import static org.mockito.Mockito.*; import static rx.operators.OperationTakeLast.*; @@ -24,6 +24,8 @@ import rx.Observable; import rx.Observer; +import rx.schedulers.TestScheduler; +import rx.subjects.PublishSubject; public class OperationTakeLastTest { @@ -110,4 +112,168 @@ public void testTakeLastWithNegativeCount() { any(IndexOutOfBoundsException.class)); verify(aObserver, never()).onCompleted(); } + + @Test + public void takeLastTimed() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler); + + Observer o = mock(Observer.class); + + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + source.onNext(1); // T: 0ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(2); // T: 250ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(3); // T: 500ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(4); // T: 750ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(5); // T: 1000ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onCompleted(); // T: 1250ms + + inOrder.verify(o, times(1)).onNext(2); + inOrder.verify(o, times(1)).onNext(3); + inOrder.verify(o, times(1)).onNext(4); + inOrder.verify(o, times(1)).onNext(5); + inOrder.verify(o, times(1)).onCompleted(); + + verify(o, never()).onError(any(Throwable.class)); + } + @Test + public void takeLastTimedDelayCompletion() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler); + + Observer o = mock(Observer.class); + + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + source.onNext(1); // T: 0ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(2); // T: 250ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(3); // T: 500ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(4); // T: 750ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(5); // T: 1000ms + scheduler.advanceTimeBy(1250, TimeUnit.MILLISECONDS); + source.onCompleted(); // T: 2250ms + + inOrder.verify(o, times(1)).onCompleted(); + + verify(o, never()).onNext(any()); + verify(o, never()).onError(any(Throwable.class)); + } + @Test + public void takeLastTimedWithCapacity() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable result = source.takeLast(2, 1, TimeUnit.SECONDS, scheduler); + + Observer o = mock(Observer.class); + + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + source.onNext(1); // T: 0ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(2); // T: 250ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(3); // T: 500ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(4); // T: 750ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(5); // T: 1000ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onCompleted(); // T: 1250ms + + inOrder.verify(o, times(1)).onNext(4); + inOrder.verify(o, times(1)).onNext(5); + inOrder.verify(o, times(1)).onCompleted(); + + verify(o, never()).onError(any(Throwable.class)); + } + static final class CustomException extends RuntimeException { + + } + @Test + public void takeLastTimedThrowingSource() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler); + + Observer o = mock(Observer.class); + + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + source.onNext(1); // T: 0ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(2); // T: 250ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(3); // T: 500ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(4); // T: 750ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(5); // T: 1000ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onError(new CustomException()); // T: 1250ms + + inOrder.verify(o, times(1)).onError(any(CustomException.class)); + + verify(o, never()).onNext(any()); + verify(o, never()).onCompleted(); + } + + @Test + public void takeLastTimedWithZeroCapacity() { + TestScheduler scheduler = new TestScheduler(); + + PublishSubject source = PublishSubject.create(); + + Observable result = source.takeLast(0, 1, TimeUnit.SECONDS, scheduler); + + Observer o = mock(Observer.class); + + InOrder inOrder = inOrder(o); + + result.subscribe(o); + + source.onNext(1); // T: 0ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(2); // T: 250ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(3); // T: 500ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(4); // T: 750ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onNext(5); // T: 1000ms + scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS); + source.onCompleted(); // T: 1250ms + + inOrder.verify(o, times(1)).onCompleted(); + + verify(o, never()).onNext(any()); + verify(o, never()).onError(any(Throwable.class)); + } } From 87f30800b455b8f336627eb039db6242587598d7 Mon Sep 17 00:00:00 2001 From: David Gross Date: Wed, 18 Dec 2013 14:01:27 -0800 Subject: [PATCH 102/441] Moved the descriptions of some operators to a new "Conditional and Boolean Operators" wiki page. --- rxjava-core/src/main/java/rx/Observable.java | 42 ++++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 5d98df26b9..04fa8e5132 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -2447,7 +2447,7 @@ public static Observable from(Future future, long timeout, T * @param the type of items emitted by each Observable * @return an Observable that emits a Boolean value that indicates whether * two sequences are equal by comparing the elements pairwise - * @see RxJava Wiki: sequenceEqual() + * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second) { return sequenceEqual(first, second, new Func2() { @@ -2476,7 +2476,7 @@ public Boolean call(T first, T second) { * @param the type of items emitted by each Observable * @return an Observable that emits a Boolean value that indicates whether * two sequences are equal by comparing the elements pairwise - * @see RxJava Wiki: sequenceEqual() + * @see RxJava Wiki: sequenceEqual() */ public static Observable sequenceEqual(Observable first, Observable second, Func2 equality) { return OperationSequenceEqual.sequenceEqual(first, second, equality); @@ -3652,7 +3652,7 @@ public Observable elementAtOrDefault(int index, T defaultValue) { * @param predicate the condition to test every item emitted by the source * Observable * @return a subscription function for creating the target Observable - * @see RxJava Wiki: exists() + * @see RxJava Wiki: exists() * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing. */ public Observable exists(Func1 predicate) { @@ -3670,7 +3670,7 @@ public Observable exists(Func1 predicate) { * @return an Observable that emits true if the specified item * is emitted by the source Observable, or false if the * source Observable completes without emitting that item - * @see RxJava Wiki: contains() + * @see RxJava Wiki: contains() * @see MSDN: Observable.Contains */ public Observable contains(final T element) { @@ -5069,7 +5069,7 @@ public Observable scan(R initialValue, Func2 accumulator * @return an Observable that emits true if all items emitted * by the source Observable satisfy the predicate; otherwise, * false - * @see RxJava Wiki: all() + * @see RxJava Wiki: all() */ public Observable all(Func1 predicate) { return create(OperationAll.all(this, predicate)); @@ -5172,7 +5172,7 @@ public Observable firstOrDefault(Func1 predicate, T defau * @return an Observable that emits either the specified default item if the * source Observable emits no items, or the items emitted by the * source Observable - * @see RxJava Wiki: defaultIfEmpty() + * @see RxJava Wiki: defaultIfEmpty() * @see MSDN: Observable.DefaultIfEmpty */ public Observable defaultIfEmpty(T defaultValue) { @@ -5212,7 +5212,7 @@ public Observable take(final int num) { * @return an Observable that emits the items from the source Observable so * long as each item satisfies the condition defined by * predicate - * @see RxJava Wiki: takeWhile() + * @see RxJava Wiki: takeWhile() */ public Observable takeWhile(final Func1 predicate) { return create(OperationTakeWhile.takeWhile(this, predicate)); @@ -5232,7 +5232,7 @@ public Observable takeWhile(final Func1 predicate) { * @return an Observable that emits items from the source Observable so long * as the predicate continues to return true for each * item, then completes - * @see RxJava Wiki: takeWhileWithIndex() + * @see RxJava Wiki: takeWhileWithIndex() */ public Observable takeWhileWithIndex(final Func2 predicate) { return create(OperationTakeWhile.takeWhileWithIndex(this, predicate)); @@ -5301,7 +5301,7 @@ public Observable takeLast(final int count) { * @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 - * @see RxJava Wiki: takeUntil() + * @see RxJava Wiki: takeUntil() */ public Observable takeUntil(Observable other) { return OperationTakeUntil.takeUntil(this, other); @@ -5320,7 +5320,7 @@ public Observable takeUntil(Observable other) { * as a second parameter. * @return an Observable that emits all items from the source Observable as * soon as the condition becomes false - * @see RxJava Wiki: skipWhileWithIndex() + * @see RxJava Wiki: skipWhileWithIndex() * @see MSDN: Observable.SkipWhile */ public Observable skipWhileWithIndex(Func2 predicate) { @@ -5338,7 +5338,7 @@ public Observable skipWhileWithIndex(Func2 predi * Observable for a condition * @return an Observable that emits all items from the source Observable as * soon as the condition becomes false - * @see RxJava Wiki: skipWhile() + * @see RxJava Wiki: skipWhile() * @see MSDN: Observable.SkipWhile */ public Observable skipWhile(Func1 predicate) { @@ -5719,7 +5719,7 @@ public Observable groupJoin(Observable right, Func1 * * @return an Observable that emits a Boolean - * @see RxJava Wiki: isEmpty() + * @see RxJava Wiki: isEmpty() * @see MSDN: Observable.Any */ public Observable isEmpty() { @@ -5964,7 +5964,7 @@ public static Observable using(Func0RxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2) { @@ -5981,7 +5981,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3) { @@ -5999,7 +5999,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) { @@ -6018,7 +6018,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) { @@ -6038,7 +6038,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) { @@ -6059,7 +6059,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) { @@ -6081,7 +6081,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) { @@ -6104,7 +6104,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) { @@ -6119,7 +6119,7 @@ public static Observable amb(Observable o1, ObservableRxJava Wiki: amb() + * @see RxJava Wiki: amb() * @see MSDN: Observable.Amb */ public static Observable amb(Iterable> sources) { From 06081552d267c7204c8a873ce5b3fb04b0703943 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Mon, 25 Nov 2013 11:14:58 +0800 Subject: [PATCH 103/441] Fixed the blocking/non-blocking first --- rxjava-core/src/main/java/rx/Observable.java | 30 ++++---- .../rx/observables/BlockingObservable.java | 69 ++++++++++++++++++ .../src/test/java/rx/ObservableTests.java | 34 ++++++--- .../observables/BlockingObservableTest.java | 70 +++++++++++++++++++ 4 files changed, 178 insertions(+), 25 deletions(-) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 04fa8e5132..8b1393d4e6 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -5093,35 +5093,33 @@ public Observable skip(int num) { /** * Returns an Observable that emits only the very first item emitted by the - * source Observable. + * source Observable, or an IllegalArgumentException if the source + * {@link Observable} is empty. *

    * * - * @return an Observable that emits only the very first item emitted by the - * source Observable, or nothing if the source Observable completes - * without emitting a single item + * @return an Observable that emits only the very first item from the + * source, or an IllegalArgumentException if the source {@link Observable} is empty. * @see RxJava Wiki: first() - * @see MSDN: Observable.First */ public Observable first() { - return take(1); + return takeFirst().last(); } /** * Returns an Observable that emits only the very first item emitted by the - * source Observable that satisfies a given condition. + * source Observable that satisfies a given condition, or an IllegalArgumentException + * if no such items are emitted. *

    * * * @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 nothing if the source - * Observable completes without emitting a single matching item + * given condition from the source, or an IllegalArgumentException if no such items are emitted. * @see RxJava Wiki: first() - * @see MSDN: Observable.First */ public Observable first(Func1 predicate) { - return skipWhile(not(predicate)).take(1); + return takeFirst(predicate).last(); } /** @@ -5245,14 +5243,13 @@ public Observable takeWhileWithIndex(final Func2 * * @return an Observable that emits only the very first item from the - * source, or none if the source Observable completes without + * source, or an empty Observable if the source Observable completes without * emitting a single item * @see RxJava Wiki: first() * @see MSDN: Observable.First - * @see #first() */ public Observable takeFirst() { - return first(); + return take(1); } /** @@ -5263,14 +5260,13 @@ public Observable takeFirst() { * * @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 + * given condition from the source, or an empty Observable if the source Observable * completes without emitting a single matching item * @see RxJava Wiki: first() * @see MSDN: Observable.First - * @see #first(Func1) */ public Observable takeFirst(Func1 predicate) { - return first(predicate); + return skipWhile(not(predicate)).take(1); } /** diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java index 8fe13c9e88..8570b38673 100644 --- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java +++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java @@ -172,6 +172,75 @@ public Iterator getIterator() { return OperationToIterator.toIterator(o); } + /** + * Returns the first item emitted by a specified {@link Observable}, + * or IllegalArgumentException if source contains no elements + * + * @return the first item emitted by the source {@link Observable} + * @throws IllegalArgumentException + * if source contains no elements + */ + public T first() { + return from(o.first()).single(); + } + + /** + * Returns the first item emitted by a specified {@link Observable} that matches a predicate, + * or IllegalArgumentException if no such items are emitted. + * + * @param predicate + * a predicate function to evaluate items emitted by the {@link Observable} + * @return the first item emitted by the {@link Observable} that matches the predicate + * @throws IllegalArgumentException + * if no such items are emitted. + */ + public T first(Func1 predicate) { + return from(o.first(predicate)).single(); + } + + /** + * Returns the first item emitted by a specified {@link Observable}, or a default value if no + * items are emitted. + * + * @param defaultValue + * a default value to return if the {@link Observable} emits no items + * @return the first item emitted by the {@link Observable}, or the default value if no items + * are emitted + * @see MSDN: Observable.FirstOrDefault + */ + public T firstOrDefault(T defaultValue) { + boolean found = false; + T result = null; + + for (T value : toIterable()) { + found = true; + result = value; + break; + } + + if (!found) { + return defaultValue; + } + + return result; + } + + /** + * Returns the first item emitted by a specified {@link Observable} that matches a predicate, or + * a default value if no such items are emitted. + * + * @param defaultValue + * a default value to return if the {@link Observable} emits no matching items + * @param predicate + * a predicate function to evaluate items emitted by the {@link Observable} + * @return the first item emitted by the {@link Observable} that matches the predicate, or the + * default value if no matching items are emitted + * @see MSDN: Observable.FirstOrDefault + */ + public T firstOrDefault(T defaultValue, Func1 predicate) { + return from(o.filter(predicate)).firstOrDefault(defaultValue); + } + /** * Returns the last item emitted by a specified {@link Observable}. *

    diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java index 3b94095c27..b02afea164 100644 --- a/rxjava-core/src/test/java/rx/ObservableTests.java +++ b/rxjava-core/src/test/java/rx/ObservableTests.java @@ -164,9 +164,9 @@ public Subscription onSubscribe(Observer obsv) { verify(w, times(1)).onError(any(RuntimeException.class)); } - public void testFirstWithPredicateOfSome() { + public void testTakeFirstWithPredicateOfSome() { Observable observable = Observable.from(1, 3, 5, 4, 6, 3); - observable.first(IS_EVEN).subscribe(w); + observable.takeFirst(IS_EVEN).subscribe(w); verify(w, times(1)).onNext(anyInt()); verify(w).onNext(4); verify(w, times(1)).onCompleted(); @@ -174,18 +174,18 @@ public void testFirstWithPredicateOfSome() { } @Test - public void testFirstWithPredicateOfNoneMatchingThePredicate() { + public void testTakeFirstWithPredicateOfNoneMatchingThePredicate() { Observable observable = Observable.from(1, 3, 5, 7, 9, 7, 5, 3, 1); - observable.first(IS_EVEN).subscribe(w); + observable.takeFirst(IS_EVEN).subscribe(w); verify(w, never()).onNext(anyInt()); verify(w, times(1)).onCompleted(); verify(w, never()).onError(any(Throwable.class)); } @Test - public void testFirstOfSome() { + public void testTakeFirstOfSome() { Observable observable = Observable.from(1, 2, 3); - observable.first().subscribe(w); + observable.takeFirst().subscribe(w); verify(w, times(1)).onNext(anyInt()); verify(w).onNext(1); verify(w, times(1)).onCompleted(); @@ -193,14 +193,32 @@ public void testFirstOfSome() { } @Test - public void testFirstOfNone() { + public void testTakeFirstOfNone() { Observable observable = Observable.empty(); - observable.first().subscribe(w); + observable.takeFirst().subscribe(w); verify(w, never()).onNext(anyInt()); verify(w, times(1)).onCompleted(); verify(w, never()).onError(any(Throwable.class)); } + @Test + public void testFirstOfNone() { + Observable observable = Observable.empty(); + observable.first().subscribe(w); + verify(w, never()).onNext(anyInt()); + verify(w, never()).onCompleted(); + verify(w, times(1)).onError(isA(IllegalArgumentException.class)); + } + + @Test + public void testFirstWithPredicateOfNoneMatchingThePredicate() { + Observable observable = Observable.from(1, 3, 5, 7, 9, 7, 5, 3, 1); + observable.first(IS_EVEN).subscribe(w); + verify(w, never()).onNext(anyInt()); + verify(w, never()).onCompleted(); + verify(w, times(1)).onError(isA(IllegalArgumentException.class)); + } + @Test public void testReduce() { Observable observable = Observable.from(1, 2, 3, 4); diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java index f3e05189c1..15454b4f7b 100644 --- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java +++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java @@ -257,6 +257,76 @@ public void call(String t1) { } } + @Test + public void testFirst() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + assertEquals("one", observable.first()); + } + + @Test(expected = IllegalArgumentException.class) + public void testFirstWithEmpty() { + BlockingObservable.from(Observable.empty()).first(); + } + + @Test + public void testFirstWithPredicate() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + String first = observable.first(new Func1() { + @Override + public Boolean call(String args) { + return args.length() > 3; + } + }); + assertEquals("three", first); + } + + @Test(expected = IllegalArgumentException.class) + public void testFirstWithPredicateAndEmpty() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + observable.first(new Func1() { + @Override + public Boolean call(String args) { + return args.length() > 5; + } + }); + } + + @Test + public void testFirstOrDefault() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + assertEquals("one", observable.firstOrDefault("default")); + } + + @Test + public void testFirstOrDefaultWithEmpty() { + BlockingObservable observable = BlockingObservable.from(Observable.empty()); + assertEquals("default", observable.firstOrDefault("default")); + } + + @Test + public void testFirstOrDefaultWithPredicate() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + String first = observable.firstOrDefault("default", new Func1() { + @Override + public Boolean call(String args) { + return args.length() > 3; + } + }); + assertEquals("three", first); + } + + @Test + public void testFirstOrDefaultWithPredicateAndEmpty() { + BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); + String first = observable.firstOrDefault("default", new Func1() { + @Override + public Boolean call(String args) { + return args.length() > 5; + } + }); + assertEquals("default", first); + } + private static class TestException extends RuntimeException { private static final long serialVersionUID = 1L; } From 21e7523bd0f6cc845cf65729df9e6960b9ee38f3 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Wed, 27 Nov 2013 14:39:44 +0800 Subject: [PATCH 104/441] Add MSDN links --- .../src/main/java/rx/observables/BlockingObservable.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java index 8570b38673..32da6fefd6 100644 --- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java +++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java @@ -179,6 +179,7 @@ public Iterator getIterator() { * @return the first item emitted by the source {@link Observable} * @throws IllegalArgumentException * if source contains no elements + * @see MSDN: Observable.First */ public T first() { return from(o.first()).single(); @@ -193,6 +194,7 @@ public T first() { * @return the first item emitted by the {@link Observable} that matches the predicate * @throws IllegalArgumentException * if no such items are emitted. + * @see MSDN: Observable.First */ public T first(Func1 predicate) { return from(o.first(predicate)).single(); From e20613bed125bf44c98bbf6aa03912f72ebe4780 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Fri, 6 Dec 2013 11:19:44 +0800 Subject: [PATCH 105/441] Mark takeFirst deprecated --- rxjava-core/src/main/java/rx/Observable.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 8b1393d4e6..a7ce09027c 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -5245,9 +5245,11 @@ public Observable takeWhileWithIndex(final Func2take(1) directly. * @see RxJava Wiki: first() * @see MSDN: Observable.First */ + @Deprecated public Observable takeFirst() { return take(1); } From 96064c37af520de375929ae8962c527dd869ad57 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Thu, 19 Dec 2013 22:48:52 +0800 Subject: [PATCH 106/441] Implement the blocking/non-blocking single, singleOrDefault, first, firstOrDefault, last, lastOrDefault --- rxjava-core/src/main/java/rx/Observable.java | 137 +++++++++- .../rx/observables/BlockingObservable.java | 86 ++----- .../rx/operators/OperationFirstOrDefault.java | 119 --------- .../main/java/rx/operators/OperationLast.java | 82 ------ .../java/rx/operators/OperationSingle.java | 96 +++++++ .../observables/BlockingObservableTest.java | 8 +- .../OperationFirstOrDefaultTest.java | 221 +++++++++++++++- .../java/rx/operators/OperationLastTest.java | 224 +++++++++++++++- .../rx/operators/OperationSingleTest.java | 242 ++++++++++++++++++ 9 files changed, 934 insertions(+), 281 deletions(-) delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationFirstOrDefault.java delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationLast.java create mode 100644 rxjava-core/src/main/java/rx/operators/OperationSingle.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationSingleTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index a7ce09027c..c0027d1bf7 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -52,14 +52,12 @@ import rx.operators.OperationElementAt; import rx.operators.OperationFilter; import rx.operators.OperationFinally; -import rx.operators.OperationFirstOrDefault; import rx.operators.OperationGroupBy; import rx.operators.OperationGroupByUntil; import rx.operators.OperationGroupJoin; import rx.operators.OperationInterval; import rx.operators.OperationJoin; import rx.operators.OperationJoinPatterns; -import rx.operators.OperationLast; import rx.operators.OperationMap; import rx.operators.OperationMaterialize; import rx.operators.OperationMerge; @@ -78,6 +76,7 @@ import rx.operators.OperationSample; import rx.operators.OperationScan; import rx.operators.OperationSequenceEqual; +import rx.operators.OperationSingle; import rx.operators.OperationSkip; import rx.operators.OperationSkipLast; import rx.operators.OperationSkipUntil; @@ -5091,6 +5090,78 @@ public Observable skip(int num) { return create(OperationSkip.skip(this, num)); } + /** + * If the Observable completes after emitting a single item, return an + * Observable containing that item. If it emits more than one item or no + * item, throw an IllegalArgumentException. + * + * @return an Observable containing the single item emitted by the source + * Observable that matches the predicate. + * @throws IllegalArgumentException + * if the source emits more than one item or no item + */ + public Observable single() { + return create(OperationSingle. single(this)); + } + + /** + * If the Observable completes after emitting a single item that matches a + * predicate, return an Observable containing that item. If it emits more + * than one such item or no item, throw an IllegalArgumentException. + * + * @param predicate + * a predicate function to evaluate items emitted by the source + * Observable + * @return an Observable containing the single item emitted by the source + * Observable that matches the predicate. + * @throws IllegalArgumentException + * if the source emits more than one item or no item matching + * the predicate + */ + public Observable single(Func1 predicate) { + return filter(predicate).single(); + } + + /** + * If the Observable completes after emitting a single item, return an + * Observable containing that item. If it's empty, return an Observable + * containing the defaultValue. If it emits more than one item, throw an + * IllegalArgumentException. + * + * @param defaultValue + * a default value to return if the Observable emits no item + * @return an Observable containing the single item emitted by the source + * Observable, or an Observable containing the defaultValue if no + * item. + * @throws IllegalArgumentException + * if the source emits more than one item + */ + public Observable singleOrDefault(T defaultValue) { + return create(OperationSingle. singleOrDefault(this, defaultValue)); + } + + /** + * If the Observable completes after emitting a single item that matches a + * predicate, return an Observable containing that item. If it emits no such + * item, return an Observable containing the defaultValue. If it emits more + * than one such item, throw an IllegalArgumentException. + * + * @param defaultValue + * a default value to return if the {@link Observable} emits no + * matching items + * @param predicate + * a predicate function to evaluate items emitted by the + * Observable + * @return an Observable containing the single item emitted by the source + * Observable that matches the predicate, or an Observable + * containing the defaultValue if no item matches the predicate + * @throws IllegalArgumentException + * if the source emits more than one item matching the predicate + */ + public Observable singleOrDefault(T defaultValue, Func1 predicate) { + return filter(predicate).singleOrDefault(defaultValue); + } + /** * Returns an Observable that emits only the very first item emitted by the * source Observable, or an IllegalArgumentException if the source @@ -5103,7 +5174,7 @@ public Observable skip(int num) { * @see RxJava Wiki: first() */ public Observable first() { - return takeFirst().last(); + return take(1).single(); } /** @@ -5119,7 +5190,7 @@ public Observable first() { * @see RxJava Wiki: first() */ public Observable first(Func1 predicate) { - return takeFirst(predicate).last(); + return takeFirst(predicate).single(); } /** @@ -5137,7 +5208,7 @@ public Observable first(Func1 predicate) { * @see MSDN: Observable.FirstOrDefault */ public Observable firstOrDefault(T defaultValue) { - return create(OperationFirstOrDefault.firstOrDefault(this, defaultValue)); + return take(1).singleOrDefault(defaultValue); } /** @@ -5155,8 +5226,8 @@ public Observable firstOrDefault(T defaultValue) { * @see RxJava Wiki: firstOrDefault() * @see MSDN: Observable.FirstOrDefault */ - public Observable firstOrDefault(Func1 predicate, T defaultValue) { - return create(OperationFirstOrDefault.firstOrDefault(this, predicate, defaultValue)); + public Observable firstOrDefault(T defaultValue, Func1 predicate) { + return takeFirst(predicate).singleOrDefault(defaultValue); } /** @@ -5268,7 +5339,7 @@ public Observable takeFirst() { * @see MSDN: Observable.First */ public Observable takeFirst(Func1 predicate) { - return skipWhile(not(predicate)).take(1); + return filter(predicate).take(1); } /** @@ -5723,7 +5794,7 @@ public Observable groupJoin(Observable right, Func1 isEmpty() { return create(OperationAny.isEmpty(this)); } - + /** * Returns an Observable that emits the last item emitted by the source or * notifies observers of an IllegalArgumentException if the @@ -5736,7 +5807,53 @@ public Observable isEmpty() { * @see RxJava Wiki: last() */ public Observable last() { - return create(OperationLast.last(this)); + return takeLast(1).single(); + } + + /** + * Returns an Observable that emits only the last item emitted by the source + * Observable that satisfies a given condition, or an + * IllegalArgumentException if no such items are emitted. + * + * @param predicate + * the condition any source emitted item has to satisfy + * @return an Observable that emits only the last item satisfying the given + * condition from the source, or an IllegalArgumentException if no + * such items are emitted. + * @throws IllegalArgumentException + * if no such itmes are emmited + */ + public Observable last(Func1 predicate) { + return filter(predicate).takeLast(1).single(); + } + + /** + * Returns an Observable that emits only the last item emitted by the source + * Observable, or a default item if the source is empty. + * + * @param defaultValue + * the default item to emit if the source Observable is empty + * @return an Observable that emits only the last item from the source, or a + * default item if the source is empty + */ + public Observable lastOrDefault(T defaultValue) { + return takeLast(1).singleOrDefault(defaultValue); + } + + /** + * Returns an Observable that emits only the last item emitted by the source + * Observable that satisfies a given condition, or a default item otherwise. + * + * @param defaultValue + * the default item to emit if the source Observable doesn't emit + * anything that satisfies the given condition + * @param predicate + * the condition any source emitted item has to satisfy + * @return an Observable that emits only the last item from the source that + * satisfies the given condition, or a default item otherwise + */ + public Observable lastOrDefault(T defaultValue, Func1 predicate) { + return filter(predicate).takeLast(1).singleOrDefault(defaultValue); } /** diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java index 32da6fefd6..9f1d88e3f3 100644 --- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java +++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java @@ -62,25 +62,6 @@ public static BlockingObservable from(final Observable o) { return new BlockingObservable(o); } - private static T _singleOrDefault(BlockingObservable source, boolean hasDefault, T defaultValue) { - Iterator it = source.toIterable().iterator(); - - if (!it.hasNext()) { - if (hasDefault) { - return defaultValue; - } - throw new IllegalStateException("Expected single entry. Actually empty stream."); - } - - T result = it.next(); - - if (it.hasNext()) { - throw new IllegalStateException("Expected single entry. Actually more than one entry."); - } - - return result; - } - /** * Used for protecting against errors being thrown from {@link Observer} implementations and * ensuring onNext/onError/onCompleted contract compliance. @@ -211,20 +192,7 @@ public T first(Func1 predicate) { * @see MSDN: Observable.FirstOrDefault */ public T firstOrDefault(T defaultValue) { - boolean found = false; - T result = null; - - for (T value : toIterable()) { - found = true; - result = value; - break; - } - - if (!found) { - return defaultValue; - } - - return result; + return from(o.take(1)).singleOrDefault(defaultValue); } /** @@ -244,7 +212,8 @@ public T firstOrDefault(T defaultValue, Func1 predicate) { } /** - * Returns the last item emitted by a specified {@link Observable}. + * Returns the last item emitted by a specified {@link Observable}, or throws IllegalArgumentException + * if source contains no elements. *

    * * @@ -252,20 +221,23 @@ public T firstOrDefault(T defaultValue, Func1 predicate) { * @throws IllegalArgumentException if source contains no elements */ public T last() { - return new BlockingObservable(o.last()).single(); + return from(o.last()).single(); } /** - * Returns the last item emitted by a specified {@link Observable} that matches a predicate. + * Returns the last item emitted by a specified {@link Observable} that matches a predicate, + * or throws IllegalArgumentException if no such items are emitted. *

    * * * @param predicate * a predicate function to evaluate items emitted by the {@link Observable} * @return the last item emitted by the {@link Observable} that matches the predicate + * @throws IllegalArgumentException + * if no such items are emitted. */ public T last(final Func1 predicate) { - return from(o.filter(predicate)).last(); + return from(o.last(predicate)).single(); } /** @@ -280,19 +252,7 @@ public T last(final Func1 predicate) { * are emitted */ public T lastOrDefault(T defaultValue) { - boolean found = false; - T result = null; - - for (T value : toIterable()) { - found = true; - result = value; - } - - if (!found) { - return defaultValue; - } - - return result; + return from(o.takeLast(1)).singleOrDefault(defaultValue); } /** @@ -339,19 +299,19 @@ public Iterable next() { /** * If the {@link Observable} completes after emitting a single item, return that item, - * otherwise throw an exception. + * otherwise throw an IllegalArgumentException. *

    * * * @return the single item emitted by the {@link Observable} */ public T single() { - return _singleOrDefault(this, false, null); + return from(o.single()).toIterable().iterator().next(); } /** * If the {@link Observable} completes after emitting a single item that matches a given - * predicate, return that item, otherwise throw an exception. + * predicate, return that item, otherwise throw an IllegalArgumentException. *

    * * @@ -360,12 +320,12 @@ public T single() { * @return the single item emitted by the source {@link Observable} that matches the predicate */ public T single(Func1 predicate) { - return _singleOrDefault(from(o.filter(predicate)), false, null); + return from(o.single(predicate)).toIterable().iterator().next(); } /** * If the {@link Observable} completes after emitting a single item, return that item; if it - * emits more than one item, throw an exception; if it emits no items, return a default value. + * emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value. *

    * * @@ -375,12 +335,22 @@ public T single(Func1 predicate) { * are emitted */ public T singleOrDefault(T defaultValue) { - return _singleOrDefault(this, true, defaultValue); + Iterator it = this.toIterable().iterator(); + + if (!it.hasNext()) { + return defaultValue; + } + + T result = it.next(); + if (it.hasNext()) { + throw new IllegalArgumentException("Sequence contains too many elements"); + } + return result; } /** * If the {@link Observable} completes after emitting a single item that matches a predicate, - * return that item; if it emits more than one such item, throw an exception; if it emits no + * return that item; if it emits more than one such item, throw an IllegalArgumentException; if it emits no * items, return a default value. *

    * @@ -393,7 +363,7 @@ public T singleOrDefault(T defaultValue) { * default value if no such items are emitted */ public T singleOrDefault(T defaultValue, Func1 predicate) { - return _singleOrDefault(from(o.filter(predicate)), true, defaultValue); + return from(o.filter(predicate)).singleOrDefault(defaultValue); } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationFirstOrDefault.java b/rxjava-core/src/main/java/rx/operators/OperationFirstOrDefault.java deleted file mode 100644 index 1a37d68d73..0000000000 --- a/rxjava-core/src/main/java/rx/operators/OperationFirstOrDefault.java +++ /dev/null @@ -1,119 +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.operators; - -import static rx.util.functions.Functions.*; - -import java.util.concurrent.atomic.AtomicBoolean; - -import rx.Observable; -import rx.Observable.OnSubscribeFunc; -import rx.Observer; -import rx.Subscription; -import rx.subscriptions.Subscriptions; -import rx.util.functions.Action0; -import rx.util.functions.Func1; - -/** - * Returns an Observable that emits the first item emitted by the source - * Observable, or a default value if the source emits nothing. - */ -public final class OperationFirstOrDefault { - - /** - * Returns an Observable that emits the first item emitted by the source - * Observable that satisfies the given condition, - * or a default value if the source emits no items that satisfy the given condition. - * - * @param source - * The source Observable to emit the first item for. - * @param predicate - * The condition the emitted source items have to satisfy. - * @param defaultValue - * The default value to use whenever the source Observable doesn't emit anything. - * @return A subscription function for creating the target Observable. - */ - public static OnSubscribeFunc firstOrDefault(Observable source, Func1 predicate, T defaultValue) { - return new FirstOrElse(source, predicate, defaultValue); - } - - /** - * Returns an Observable that emits the first item emitted by the source - * Observable, or a default value if the source emits nothing. - * - * @param source - * The source Observable to emit the first item for. - * @param defaultValue - * The default value to use whenever the source Observable doesn't emit anything. - * @return A subscription function for creating the target Observable. - */ - public static OnSubscribeFunc firstOrDefault(Observable source, T defaultValue) { - return new FirstOrElse(source, alwaysTrue(), defaultValue); - } - - private static class FirstOrElse implements OnSubscribeFunc { - private final Observable source; - private final Func1 predicate; - private final T defaultValue; - - private FirstOrElse(Observable source, Func1 predicate, T defaultValue) { - this.source = source; - this.defaultValue = defaultValue; - this.predicate = predicate; - } - - @Override - public Subscription onSubscribe(final Observer observer) { - final Subscription sourceSub = source.subscribe(new Observer() { - private final AtomicBoolean hasEmitted = new AtomicBoolean(false); - - @Override - public void onCompleted() { - if (!hasEmitted.get()) { - observer.onNext(defaultValue); - observer.onCompleted(); - } - } - - @Override - public void onError(Throwable e) { - observer.onError(e); - } - - @Override - public void onNext(T next) { - try { - if (!hasEmitted.get() && predicate.call(next)) { - hasEmitted.set(true); - observer.onNext(next); - observer.onCompleted(); - } - } catch (Throwable t) { - // may happen within the predicate call (user code) - observer.onError(t); - } - } - }); - - return Subscriptions.create(new Action0() { - @Override - public void call() { - sourceSub.unsubscribe(); - } - }); - } - } -} diff --git a/rxjava-core/src/main/java/rx/operators/OperationLast.java b/rxjava-core/src/main/java/rx/operators/OperationLast.java deleted file mode 100644 index 964afd5176..0000000000 --- a/rxjava-core/src/main/java/rx/operators/OperationLast.java +++ /dev/null @@ -1,82 +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.operators; - -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; - -import rx.Observable; -import rx.Observable.OnSubscribeFunc; -import rx.Observer; -import rx.Subscription; - -/** - * Emit an Observable with the last emitted item - * or onError(new IllegalArgumentException("Sequence contains no elements")) if no elements received. - */ -public class OperationLast { - - /** - * Accepts a sequence and returns a sequence that is the last emitted item - * or an error if no items are emitted (empty sequence). - * - * @param sequence - * the input sequence. - * @param - * the type of the sequence. - * @return a sequence containing the last emitted item or that has onError invoked on it if no items - */ - public static OnSubscribeFunc last(final Observable sequence) { - return new OnSubscribeFunc() { - final AtomicReference last = new AtomicReference(); - final AtomicBoolean hasLast = new AtomicBoolean(false); - - @Override - public Subscription onSubscribe(final Observer observer) { - return sequence.subscribe(new Observer() { - - @Override - public void onCompleted() { - /* - * We don't need to worry about the following being non-atomic - * since an Observable sequence is serial so we will not receive - * concurrent executions. - */ - if (hasLast.get()) { - observer.onNext(last.get()); - observer.onCompleted(); - } else { - observer.onError(new IllegalArgumentException("Sequence contains no elements")); - } - } - - @Override - public void onError(Throwable e) { - observer.onError(e); - } - - @Override - public void onNext(T value) { - last.set(value); - hasLast.set(true); - } - }); - } - - }; - } - -} diff --git a/rxjava-core/src/main/java/rx/operators/OperationSingle.java b/rxjava-core/src/main/java/rx/operators/OperationSingle.java new file mode 100644 index 0000000000..a30770c1f0 --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationSingle.java @@ -0,0 +1,96 @@ +/** + * 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 rx.Observable; +import rx.Observable.OnSubscribeFunc; +import rx.Observer; +import rx.Subscription; + +/** + * If the Observable completes after emitting a single item that matches a + * predicate, return an Observable containing that item. If it emits more than + * one such item or no item, throw an IllegalArgumentException. + */ +public class OperationSingle { + + public static OnSubscribeFunc single( + final Observable source) { + return single(source, false, null); + } + + public static OnSubscribeFunc singleOrDefault( + final Observable source, final T defaultValue) { + return single(source, true, defaultValue); + } + + private static OnSubscribeFunc single( + final Observable source, + final boolean hasDefaultValue, final T defaultValue) { + return new OnSubscribeFunc() { + + @Override + public Subscription onSubscribe(final Observer observer) { + final SafeObservableSubscription subscription = new SafeObservableSubscription(); + subscription.wrap(source.subscribe(new Observer() { + + private volatile T value; + private volatile boolean isEmpty = true; + private volatile boolean hasTooManyElemenets; + + @Override + public void onCompleted() { + if (hasTooManyElemenets) { + // We has already sent an onError message + } else { + if (isEmpty) { + if (hasDefaultValue) { + observer.onNext(defaultValue); + observer.onCompleted(); + } else { + observer.onError(new IllegalArgumentException( + "Sequence contains no elements")); + } + } else { + observer.onNext(value); + observer.onCompleted(); + } + } + } + + @Override + public void onError(Throwable e) { + observer.onError(e); + } + + @Override + public void onNext(T value) { + if (isEmpty) { + this.value = value; + isEmpty = false; + } else { + hasTooManyElemenets = true; + observer.onError(new IllegalArgumentException( + "Sequence contains too many elements")); + subscription.unsubscribe(); + } + } + })); + return subscription; + } + }; + } +} diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java index 15454b4f7b..d5ebbab904 100644 --- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java +++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java @@ -127,7 +127,7 @@ public void testSingleDefault() { assertEquals("default", observable.singleOrDefault("default")); } - @Test(expected = IllegalStateException.class) + @Test(expected = IllegalArgumentException.class) public void testSingleDefaultPredicateMatchesMoreThanOne() { BlockingObservable.from(Observable.from("one", "two")).singleOrDefault("default", new Func1() { @Override @@ -149,7 +149,7 @@ public Boolean call(String args) { assertEquals("default", result); } - @Test(expected = IllegalStateException.class) + @Test(expected = IllegalArgumentException.class) public void testSingleDefaultWithMoreThanOne() { BlockingObservable observable = BlockingObservable.from(Observable.from("one", "two", "three")); observable.singleOrDefault("default"); @@ -166,13 +166,13 @@ public Boolean call(String s) { })); } - @Test(expected = IllegalStateException.class) + @Test(expected = IllegalArgumentException.class) public void testSingleWrong() { BlockingObservable observable = BlockingObservable.from(Observable.from(1, 2)); observable.single(); } - @Test(expected = IllegalStateException.class) + @Test(expected = IllegalArgumentException.class) public void testSingleWrongPredicate() { BlockingObservable observable = BlockingObservable.from(Observable.from(-1)); observable.single(new Func1() { diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java index 026caa1319..dfa4de615f 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java @@ -18,10 +18,10 @@ import static org.mockito.Matchers.*; import static org.mockito.Mockito.*; import static org.mockito.MockitoAnnotations.*; -import static rx.operators.OperationFirstOrDefault.*; import org.junit.Before; import org.junit.Test; +import org.mockito.InOrder; import org.mockito.Mock; import rx.Observable; @@ -48,7 +48,7 @@ public void before() { @Test public void testFirstOrElseOfNone() { Observable src = Observable.empty(); - Observable.create(firstOrDefault(src, "default")).subscribe(w); + src.firstOrDefault("default").subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("default"); @@ -59,7 +59,7 @@ public void testFirstOrElseOfNone() { @Test public void testFirstOrElseOfSome() { Observable src = Observable.from("a", "b", "c"); - Observable.create(firstOrDefault(src, "default")).subscribe(w); + src.firstOrDefault("default").subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("a"); @@ -70,7 +70,7 @@ public void testFirstOrElseOfSome() { @Test public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() { Observable src = Observable.from("a", "b", "c"); - Observable.create(firstOrDefault(src, IS_D, "default")).subscribe(w); + src.firstOrDefault("default", IS_D).subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("default"); @@ -81,11 +81,222 @@ public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() { @Test public void testFirstOrElseWithPredicateOfSome() { Observable src = Observable.from("a", "b", "c", "d", "e", "f"); - Observable.create(firstOrDefault(src, IS_D, "default")).subscribe(w); + src.firstOrDefault("default", IS_D).subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("d"); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onCompleted(); } + + @Test + public void testFirst() { + Observable observable = Observable.from(1, 2, 3).first(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstWithOneElement() { + Observable observable = Observable.from(1).first(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstWithEmpty() { + Observable observable = Observable. empty().first(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstWithPredicate() { + Observable observable = Observable.from(1, 2, 3, 4, 5, 6) + .first(new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstWithPredicateAndOneElement() { + Observable observable = Observable.from(1, 2).first( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstWithPredicateAndEmpty() { + Observable observable = Observable.from(1).first( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefault() { + Observable observable = Observable.from(1, 2, 3) + .firstOrDefault(4); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefaultWithOneElement() { + Observable observable = Observable.from(1).firstOrDefault(2); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefaultWithEmpty() { + Observable observable = Observable. empty() + .firstOrDefault(1); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefaultWithPredicate() { + Observable observable = Observable.from(1, 2, 3, 4, 5, 6) + .firstOrDefault(8, new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefaultWithPredicateAndOneElement() { + Observable observable = Observable.from(1, 2).firstOrDefault( + 4, new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testFirstOrDefaultWithPredicateAndEmpty() { + Observable observable = Observable.from(1).firstOrDefault(2, + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java index 006de63060..cfd292cff2 100644 --- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java +++ b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java @@ -16,28 +16,35 @@ package rx.operators; import static org.junit.Assert.*; +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; import org.junit.Test; +import org.mockito.InOrder; import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; public class OperationLastTest { @Test public void testLastWithElements() { - Observable last = Observable.create(OperationLast.last(Observable.from(1, 2, 3))); + Observable last = Observable.from(1, 2, 3).last(); assertEquals(3, last.toBlockingObservable().single().intValue()); } @Test(expected = IllegalArgumentException.class) public void testLastWithNoElements() { - Observable last = Observable.create(OperationLast.last(Observable.empty())); + Observable last = Observable.empty().last(); last.toBlockingObservable().single(); } @Test public void testLastMultiSubscribe() { - Observable last = Observable.create(OperationLast.last(Observable.from(1, 2, 3))); + Observable last = Observable.from(1, 2, 3).last(); assertEquals(3, last.toBlockingObservable().single().intValue()); assertEquals(3, last.toBlockingObservable().single().intValue()); } @@ -46,4 +53,215 @@ public void testLastMultiSubscribe() { public void testLastViaObservable() { Observable.from(1, 2, 3).last(); } + + @Test + public void testLast() { + Observable observable = Observable.from(1, 2, 3).last(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(3); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastWithOneElement() { + Observable observable = Observable.from(1).last(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastWithEmpty() { + Observable observable = Observable. empty().last(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastWithPredicate() { + Observable observable = Observable.from(1, 2, 3, 4, 5, 6) + .last(new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(6); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastWithPredicateAndOneElement() { + Observable observable = Observable.from(1, 2).last( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastWithPredicateAndEmpty() { + Observable observable = Observable.from(1).last( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefault() { + Observable observable = Observable.from(1, 2, 3) + .lastOrDefault(4); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(3); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefaultWithOneElement() { + Observable observable = Observable.from(1).lastOrDefault(2); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefaultWithEmpty() { + Observable observable = Observable. empty() + .lastOrDefault(1); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefaultWithPredicate() { + Observable observable = Observable.from(1, 2, 3, 4, 5, 6) + .lastOrDefault(8, new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(6); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefaultWithPredicateAndOneElement() { + Observable observable = Observable.from(1, 2).lastOrDefault(4, + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testLastOrDefaultWithPredicateAndEmpty() { + Observable observable = Observable.from(1).lastOrDefault(2, + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java new file mode 100644 index 0000000000..b89864b1e4 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java @@ -0,0 +1,242 @@ +/** + * 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 static org.mockito.Matchers.isA; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; + +public class OperationSingleTest { + + @Test + public void testSingle() { + Observable observable = Observable.from(1).single(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleWithTooManyElements() { + Observable observable = Observable.from(1, 2).single(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleWithEmpty() { + Observable observable = Observable. empty().single(); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleWithPredicate() { + Observable observable = Observable.from(1, 2).single( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleWithPredicateAndTooManyElements() { + Observable observable = Observable.from(1, 2, 3, 4).single( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleWithPredicateAndEmpty() { + Observable observable = Observable.from(1).single( + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefault() { + Observable observable = Observable.from(1).singleOrDefault(2); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefaultWithTooManyElements() { + Observable observable = Observable.from(1, 2).singleOrDefault( + 3); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefaultWithEmpty() { + Observable observable = Observable. empty() + .singleOrDefault(1); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefaultWithPredicate() { + Observable observable = Observable.from(1, 2).singleOrDefault( + 4, new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefaultWithPredicateAndTooManyElements() { + Observable observable = Observable.from(1, 2, 3, 4) + .singleOrDefault(6, new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testSingleOrDefaultWithPredicateAndEmpty() { + Observable observable = Observable.from(1).singleOrDefault(2, + new Func1() { + + @Override + public Boolean call(Integer t1) { + return t1 % 2 == 0; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + observable.subscribe(observer); + + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(2); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } +} From bfb9cd19cc2cc73ece9a6ca6d6623552c9938ddd Mon Sep 17 00:00:00 2001 From: zsxwing Date: Thu, 19 Dec 2013 23:38:45 +0800 Subject: [PATCH 107/441] Fix the unit tests in groovy and kotlin --- .../src/test/groovy/rx/lang/groovy/ObservableTests.groovy | 2 +- .../src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/ObservableTests.groovy b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/ObservableTests.groovy index 9c6e244149..34d90f160c 100644 --- a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/ObservableTests.groovy +++ b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/ObservableTests.groovy @@ -278,7 +278,7 @@ def class ObservableTests { assertEquals("one", s) } - @Test(expected = IllegalStateException.class) + @Test(expected = IllegalArgumentException.class) public void testSingle2() { Observable.from("one", "two").toBlockingObservable().single({ x -> x.length() == 3}) } diff --git a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt index d826585ced..9e1fde131e 100644 --- a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt +++ b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt @@ -255,7 +255,7 @@ public class BasicKotlinTests { assertEquals("default", Observable.from("one", "two")!!.toBlockingObservable()!!.lastOrDefault("default") { x -> x!!.length > 3 }) } - [Test(expected = javaClass())] + [Test(expected = javaClass())] public fun testSingle() { assertEquals("one", Observable.from("one")!!.toBlockingObservable()!!.single { x -> x!!.length == 3 }) Observable.from("one", "two")!!.toBlockingObservable()!!.single { x -> x!!.length == 3 } From a1191a2177c8479e247e19c88e766937b9ec6e98 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Fri, 20 Dec 2013 17:45:28 +0800 Subject: [PATCH 108/441] Remove volatile --- rxjava-core/src/main/java/rx/operators/OperationSingle.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rxjava-core/src/main/java/rx/operators/OperationSingle.java b/rxjava-core/src/main/java/rx/operators/OperationSingle.java index a30770c1f0..2269cd8b44 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationSingle.java +++ b/rxjava-core/src/main/java/rx/operators/OperationSingle.java @@ -47,9 +47,9 @@ public Subscription onSubscribe(final Observer observer) { final SafeObservableSubscription subscription = new SafeObservableSubscription(); subscription.wrap(source.subscribe(new Observer() { - private volatile T value; - private volatile boolean isEmpty = true; - private volatile boolean hasTooManyElemenets; + private T value; + private boolean isEmpty = true; + private boolean hasTooManyElemenets; @Override public void onCompleted() { From 6b036e80620ca834e42e42da8fb5ca069bcaccea Mon Sep 17 00:00:00 2001 From: Ben Christensen Date: Sat, 21 Dec 2013 16:14:44 -0800 Subject: [PATCH 109/441] Subject Refactor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Common logic composed inside SubjectSubscriptionManager - ReplaySubject does not block while replaying to new subscribers - Added unit tests and fixed behavior while reviewing with @headinthebox compared to Rx.Net - Uses mostly non-blocking approach (I believe it’s all correct, unit and long running tests have been used to prove it. The tests found concurrency problems during development and became stable once I got the design correct. As with all concurrent code I may be missing something.) --- .../java/rx/subjects/AbstractSubject.java | 167 ---------- .../main/java/rx/subjects/AsyncSubject.java | 107 +++--- .../java/rx/subjects/BehaviorSubject.java | 122 +++++-- .../main/java/rx/subjects/PublishSubject.java | 92 ++++-- .../main/java/rx/subjects/ReplaySubject.java | 234 +++++++------ .../subjects/SubjectSubscriptionManager.java | 187 +++++++++++ .../java/rx/subjects/UnsubscribeTester.java | 186 ----------- .../java/rx/subjects/AsyncSubjectTest.java | 25 +- .../java/rx/subjects/BehaviorSubjectTest.java | 73 ++-- .../java/rx/subjects/PublishSubjectTest.java | 27 -- ...ySubjectPerformanceAndConcurrencyTest.java | 311 ++++++++++++++++++ .../java/rx/subjects/ReplaySubjectTest.java | 113 +++++-- 12 files changed, 982 insertions(+), 662 deletions(-) delete mode 100644 rxjava-core/src/main/java/rx/subjects/AbstractSubject.java create mode 100644 rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java delete mode 100644 rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java create mode 100644 rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java diff --git a/rxjava-core/src/main/java/rx/subjects/AbstractSubject.java b/rxjava-core/src/main/java/rx/subjects/AbstractSubject.java deleted file mode 100644 index 30db331ac2..0000000000 --- a/rxjava-core/src/main/java/rx/subjects/AbstractSubject.java +++ /dev/null @@ -1,167 +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.subjects; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; -import java.util.concurrent.locks.ReentrantLock; - -import rx.Notification; -import rx.Observer; -import rx.Subscription; -import rx.operators.SafeObservableSubscription; -import rx.subscriptions.Subscriptions; -import rx.util.functions.Action2; - -public abstract class AbstractSubject extends Subject { - - protected AbstractSubject(rx.Observable.OnSubscribeFunc onSubscribe) { - super(onSubscribe); - } - - protected static class SubjectState { - protected final ConcurrentHashMap> observers = new ConcurrentHashMap>(); - protected final AtomicReference> currentValue = new AtomicReference>(); - protected final AtomicBoolean completed = new AtomicBoolean(); - protected final ReentrantLock SUBSCRIPTION_LOCK = new ReentrantLock(); - } - - protected static OnSubscribeFunc getOnSubscribeFunc(final SubjectState state, final Action2, Observer> onEach) { - return new OnSubscribeFunc() { - @Override - public Subscription onSubscribe(Observer observer) { - /* - * Subscription needs to be synchronized with terminal states to ensure - * race conditions are handled. When subscribing we must make sure - * onComplete/onError is correctly emitted to all observers, even if it - * comes in while the onComplete/onError is being propagated. - */ - state.SUBSCRIPTION_LOCK.lock(); - try { - if (state.completed.get()) { - emitNotification(state.currentValue.get(), observer); - if (onEach != null) { - onEach.call(state, observer); - } - return Subscriptions.empty(); - } else { - // the subject is not completed so we subscribe - final SafeObservableSubscription subscription = new SafeObservableSubscription(); - - subscription.wrap(new Subscription() { - @Override - public void unsubscribe() { - // on unsubscribe remove it from the map of outbound observers to notify - state.observers.remove(subscription); - } - }); - - // on subscribe add it to the map of outbound observers to notify - state.observers.put(subscription, observer); - - // invoke onSubscribe logic - if (onEach != null) { - onEach.call(state, observer); - } - - return subscription; - } - } finally { - state.SUBSCRIPTION_LOCK.unlock(); - } - - } - - }; - } - - protected static void emitNotification(Notification value, Observer observer) { - // if null that means onNext was never invoked (no Notification set) - if (value != null) { - if (value.isOnNext()) { - observer.onNext(value.getValue()); - } else if (value.isOnError()) { - observer.onError(value.getThrowable()); - } else if (value.isOnCompleted()) { - observer.onCompleted(); - } - } - } - - /** - * Emit the current value. - * - * @param state - */ - protected static void emitNotification(final SubjectState state, final Action2, Observer> onEach) { - for (Subscription s : snapshotOfObservers(state)) { - Observer o = state.observers.get(s); - // emit notifications to this observer - emitNotification(state.currentValue.get(), o); - // onEach action if applicable - if (onEach != null) { - onEach.call(state, o); - } - } - } - - /** - * Emit the current value to all observers and remove their subscription. - * - * @param state - */ - protected void emitNotificationAndTerminate(final SubjectState state, final Action2, Observer> onEach) { - /* - * We can not allow new subscribers to be added while we execute the terminal state. - */ - state.SUBSCRIPTION_LOCK.lock(); - try { - if (state.completed.compareAndSet(false, true)) { - for (Subscription s : snapshotOfObservers(state)) { - Observer o = state.observers.get(s); - // emit notifications to this observer - emitNotification(state.currentValue.get(), o); - // onEach action if applicable - if (onEach != null) { - onEach.call(state, o); - } - - // remove the subscription as it is completed - state.observers.remove(s); - } - } - } finally { - state.SUBSCRIPTION_LOCK.unlock(); - } - } - - /** - * Current snapshot of 'state.observers.keySet()' so that concurrent modifications aren't included. - * - * This makes it behave deterministically in a single-threaded execution when nesting subscribes. - * - * In multi-threaded execution it will cause new subscriptions to wait until the following onNext instead - * of possibly being included in the current onNext iteration. - * - * @return List> - */ - private static Collection snapshotOfObservers(final SubjectState state) { - return new ArrayList(state.observers.keySet()); - } -} diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java index a9c18be805..01062870da 100644 --- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java +++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java @@ -15,9 +15,12 @@ */ package rx.subjects; +import java.util.Collection; +import java.util.concurrent.atomic.AtomicReference; + import rx.Notification; import rx.Observer; -import rx.util.functions.Action2; +import rx.util.functions.Action1; /** * Subject that publishes only the last event to each {@link Observer} that has subscribed when the @@ -28,8 +31,8 @@ * Example usage: *

    * 

     {@code
-
- * / observer will receive no onNext events because the subject.onCompleted() isn't called.
+ * 
+ * // observer will receive no onNext events because the subject.onCompleted() isn't called.
   AsyncSubject subject = AsyncSubject.create();
   subject.subscribe(observer);
   subject.onNext("one");
@@ -48,68 +51,88 @@
  * 
  * @param 
  */
-public class AsyncSubject extends AbstractSubject {
+public final class AsyncSubject extends Subject {
 
-    /**
-     * Create a new AsyncSubject
-     * 
-     * @return a new AsyncSubject
-     */
     public static  AsyncSubject create() {
-        final SubjectState state = new SubjectState();
-        OnSubscribeFunc onSubscribe = getOnSubscribeFunc(state, new Action2, Observer>() {
+        final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
+        final AtomicReference> lastNotification = new AtomicReference>(new Notification());
 
-            @Override
-            public void call(SubjectState state, Observer o) {
-                // we want the last value + completed so add this extra logic 
-                // to send onCompleted if the last value is an onNext
-                if (state.completed.get()) {
-                    Notification value = state.currentValue.get();
-                    if (value != null && value.isOnNext()) {
-                        o.onCompleted();
+        OnSubscribeFunc onSubscribe = subscriptionManager.getOnSubscribeFunc(
+                /**
+                 * This function executes at beginning of subscription.
+                 * 
+                 * This will always run, even if Subject is in terminal state.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        // nothing to do if not terminated
                     }
-                }
-            }
-        });
-        return new AsyncSubject(onSubscribe, state);
+                },
+                /**
+                 * This function executes if the Subject is terminated.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        // we want the last value + completed so add this extra logic 
+                        // to send onCompleted if the last value is an onNext
+                        emitValueToObserver(lastNotification.get(), o);
+                    }
+                });
+
+        return new AsyncSubject(onSubscribe, subscriptionManager, lastNotification);
+    }
+
+    protected static  void emitValueToObserver(Notification n, Observer o) {
+        n.accept(o);
+        if (n.isOnNext()) {
+            o.onCompleted();
+        }
     }
 
-    private final SubjectState state;
+    private final SubjectSubscriptionManager subscriptionManager;
+    final AtomicReference> lastNotification;
 
-    protected AsyncSubject(OnSubscribeFunc onSubscribe, SubjectState state) {
+    protected AsyncSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManager subscriptionManager, AtomicReference> lastNotification) {
         super(onSubscribe);
-        this.state = state;
+        this.subscriptionManager = subscriptionManager;
+        this.lastNotification = lastNotification;
     }
 
     @Override
     public void onCompleted() {
-        /**
-         * Mark this subject as completed and emit latest value + 'onCompleted' to all Observers
-         */
-        emitNotificationAndTerminate(state, new Action2, Observer>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(SubjectState state, Observer o) {
-                o.onCompleted();
+            public void call(Collection> observers) {
+                for (Observer o : observers) {
+                    emitValueToObserver(lastNotification.get(), o);
+                }
             }
         });
     }
 
     @Override
-    public void onError(Throwable e) {
-        /**
-         * Mark this subject as completed with an error as the last value and emit 'onError' to all Observers
-         */
-        state.currentValue.set(new Notification(e));
-        emitNotificationAndTerminate(state, null);
+    public void onError(final Throwable e) {
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                lastNotification.set(new Notification(e));
+                for (Observer o : observers) {
+                    emitValueToObserver(lastNotification.get(), o);
+                }
+            }
+        });
+
     }
 
     @Override
     public void onNext(T v) {
-        /**
-         * Store the latest value but do not send it. It only gets sent when 'onCompleted' occurs.
-         */
-        state.currentValue.set(new Notification(v));
+        lastNotification.set(new Notification(v));
     }
 
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 053a51f0cf..723acb154d 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -15,9 +15,12 @@
  */
 package rx.subjects;
 
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Notification;
 import rx.Observer;
-import rx.util.functions.Action2;
+import rx.util.functions.Action1;
 
 /**
  * Subject that publishes the most recent and all subsequent events to each subscribed {@link Observer}.
@@ -29,25 +32,38 @@
  * 
     {@code
 
  * / observer will receive all events.
-  BehaviorSubject subject = BehaviorSubject.createWithDefaultValue("default");
+  BehaviorSubject subject = BehaviorSubject.create("default");
   subject.subscribe(observer);
   subject.onNext("one");
   subject.onNext("two");
   subject.onNext("three");
 
   // observer will receive the "one", "two" and "three" events, but not "zero"
-  BehaviorSubject subject = BehaviorSubject.createWithDefaultValue("default");
+  BehaviorSubject subject = BehaviorSubject.create("default");
   subject.onNext("zero");
   subject.onNext("one");
   subject.subscribe(observer);
   subject.onNext("two");
   subject.onNext("three");
 
+  // observer will receive only onCompleted
+  BehaviorSubject subject = BehaviorSubject.create("default");
+  subject.onNext("zero");
+  subject.onNext("one");
+  subject.onCompleted();
+  subject.subscribe(observer);
+  
+  // observer will receive only onError
+  BehaviorSubject subject = BehaviorSubject.create("default");
+  subject.onNext("zero");
+  subject.onNext("one");
+  subject.onError(new RuntimeException("error"));
+  subject.subscribe(observer);
   } 
  * 
  * @param 
  */
-public class BehaviorSubject extends AbstractSubject {
+public final class BehaviorSubject extends Subject {
 
     /**
      * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
@@ -69,54 +85,96 @@ public static  BehaviorSubject createWithDefaultValue(T defaultValue) {
      * @return the constructed {@link BehaviorSubject}.
      */
     public static  BehaviorSubject create(T defaultValue) {
-        final SubjectState state = new SubjectState();
+        final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
         // set a default value so subscriptions will immediately receive this until a new notification is received
-        state.currentValue.set(new Notification(defaultValue));
-        OnSubscribeFunc onSubscribe = getOnSubscribeFunc(state, new Action2, Observer>() {
+        final AtomicReference> lastNotification = new AtomicReference>(new Notification(defaultValue));
 
-            @Override
-            public void call(SubjectState state, Observer o) {
+        OnSubscribeFunc onSubscribe = subscriptionManager.getOnSubscribeFunc(
                 /**
-                 * When we subscribe we always emit the latest value to the observer, including
-                 * terminal states which are recorded as the last value.
+                 * This function executes at beginning of subscription.
+                 * 
+                 * This will always run, even if Subject is in terminal state.
                  */
-                emitNotification(state.currentValue.get(), o);
-            }
-        });
-        return new BehaviorSubject(onSubscribe, state);
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        /*
+                         * When we subscribe we always emit the latest value to the observer.
+                         * 
+                         * Here we only emit if it's an onNext as terminal states are handled in the next function.
+                         */
+                        Notification n = lastNotification.get();
+                        if (n.isOnNext()) {
+                            n.accept(o);
+                        }
+                    }
+                },
+                /**
+                 * This function executes if the Subject is terminated before subscription occurs.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        /*
+                         * If we are already terminated, or termination happens while trying to subscribe
+                         * this will be invoked and we emit whatever the last terminal value was.
+                         */
+                        lastNotification.get().accept(o);
+                    }
+                });
+
+        return new BehaviorSubject(onSubscribe, subscriptionManager, lastNotification);
     }
 
-    private final SubjectState state;
+    private final SubjectSubscriptionManager subscriptionManager;
+    final AtomicReference> lastNotification;
 
-    protected BehaviorSubject(OnSubscribeFunc onSubscribe, SubjectState state) {
+    protected BehaviorSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManager subscriptionManager, AtomicReference> lastNotification) {
         super(onSubscribe);
-        this.state = state;
+        this.subscriptionManager = subscriptionManager;
+        this.lastNotification = lastNotification;
     }
 
     @Override
     public void onCompleted() {
-        /**
-         * Mark this subject as completed and emit latest value + 'onCompleted' to all Observers
-         */
-        state.currentValue.set(new Notification());
-        emitNotificationAndTerminate(state, null);
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                lastNotification.set(new Notification());
+                for (Observer o : observers) {
+                    o.onCompleted();
+                }
+            }
+        });
     }
 
     @Override
-    public void onError(Throwable e) {
-        /**
-         * Mark this subject as completed with an error as the last value and emit 'onError' to all Observers
-         */
-        state.currentValue.set(new Notification(e));
-        emitNotificationAndTerminate(state, null);
+    public void onError(final Throwable e) {
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                lastNotification.set(new Notification(e));
+                for (Observer o : observers) {
+                    o.onError(e);
+                }
+            }
+        });
+
     }
 
     @Override
     public void onNext(T v) {
         /**
-         * Store the latest value and send it to all observers;
+         * Store the latest value but do not send it. It only gets sent when 'onCompleted' occurs.
          */
-        state.currentValue.set(new Notification(v));
-        emitNotification(state, null);
+        lastNotification.set(new Notification(v));
+        for (Observer o : subscriptionManager.snapshotOfObservers()) {
+            o.onNext(v);
+        }
     }
+
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 8cf2d75747..0f350e6b85 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -15,8 +15,12 @@
  */
 package rx.subjects;
 
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Notification;
 import rx.Observer;
+import rx.util.functions.Action1;
 
 /**
  * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
@@ -41,44 +45,86 @@
  * 
  * @param 
  */
-public class PublishSubject extends AbstractSubject {
+public final class PublishSubject extends Subject {
+
     public static  PublishSubject create() {
-        final SubjectState state = new SubjectState();
-        OnSubscribeFunc onSubscribe = getOnSubscribeFunc(state, null);
-        return new PublishSubject(onSubscribe, state);
+        final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
+        // set a default value so subscriptions will immediately receive this until a new notification is received
+        final AtomicReference> lastNotification = new AtomicReference>();
+
+        OnSubscribeFunc onSubscribe = subscriptionManager.getOnSubscribeFunc(
+                /**
+                 * This function executes at beginning of subscription.
+                 * 
+                 * This will always run, even if Subject is in terminal state.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        // nothing onSubscribe unless in terminal state which is the next function
+                    }
+                },
+                /**
+                 * This function executes if the Subject is terminated before subscription occurs.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        /*
+                         * If we are already terminated, or termination happens while trying to subscribe
+                         * this will be invoked and we emit whatever the last terminal value was.
+                         */
+                        lastNotification.get().accept(o);
+                    }
+                });
+
+        return new PublishSubject(onSubscribe, subscriptionManager, lastNotification);
     }
 
-    private final SubjectState state;
+    private final SubjectSubscriptionManager subscriptionManager;
+    final AtomicReference> lastNotification;
 
-    protected PublishSubject(OnSubscribeFunc onSubscribe, SubjectState state) {
+    protected PublishSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManager subscriptionManager, AtomicReference> lastNotification) {
         super(onSubscribe);
-        this.state = state;
+        this.subscriptionManager = subscriptionManager;
+        this.lastNotification = lastNotification;
     }
 
     @Override
     public void onCompleted() {
-        /**
-         * Mark this subject as completed and emit latest value + 'onCompleted' to all Observers
-         */
-        state.currentValue.set(new Notification());
-        emitNotificationAndTerminate(state, null);
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                lastNotification.set(new Notification());
+                for (Observer o : observers) {
+                    o.onCompleted();
+                }
+            }
+        });
     }
 
     @Override
-    public void onError(Throwable e) {
-        /**
-         * Mark this subject as completed with an error as the last value and emit 'onError' to all Observers
-         */
-        state.currentValue.set(new Notification(e));
-        emitNotificationAndTerminate(state, null);
+    public void onError(final Throwable e) {
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                lastNotification.set(new Notification(e));
+                for (Observer o : observers) {
+                    o.onError(e);
+                }
+            }
+        });
+
     }
 
     @Override
     public void onNext(T v) {
-        /**
-         * Store the latest value and send it to all observers;
-         */
-        state.currentValue.set(new Notification(v));
-        emitNotification(state, null);
+        for (Observer o : subscriptionManager.snapshotOfObservers()) {
+            o.onNext(v);
+        }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index c4985ba84a..3af8f85835 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -15,16 +15,12 @@
  */
 package rx.subjects;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
 
+import rx.Notification;
 import rx.Observer;
-import rx.Subscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func1;
+import rx.util.functions.Action1;
 
 /**
  * Subject that retains all events and will replay them to an {@link Observer} that subscribes.
@@ -49,128 +45,160 @@
  * 
  * @param 
  */
-public final class ReplaySubject extends Subject
-{
-
-    private boolean isDone = false;
-    private Throwable exception = null;
-    private final Map> subscriptions = new HashMap>();
-    private final List history = Collections.synchronizedList(new ArrayList());
+public final class ReplaySubject extends Subject {
 
     public static  ReplaySubject create() {
-        return new ReplaySubject(new DelegateSubscriptionFunc());
-    }
+        final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
+        final ReplayState state = new ReplayState();
+
+        OnSubscribeFunc onSubscribe = subscriptionManager.getOnSubscribeFunc(
+                /**
+                 * This function executes at beginning of subscription.
+                 * We want to replay history with the subscribing thread
+                 * before the Observer gets registered.
+                 * 
+                 * This will always run, even if Subject is in terminal state.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        // replay history for this observer using the subscribing thread
+                        Link last = replayObserverFromLink(state.history.head, o);
+
+                        // now that it is caught up add to observers
+                        state.replayState.put(o, last);
+                    }
+                },
+                /**
+                 * This function executes if the Subject is terminated.
+                 */
+                new Action1>() {
+
+                    @Override
+                    public void call(Observer o) {
+                        // we will finish replaying if there is anything left
+                        replayObserverFromLink(state.replayState.get(o), o);
+                    }
+                });
 
-    private ReplaySubject(DelegateSubscriptionFunc onSubscribe) {
-        super(onSubscribe);
-        onSubscribe.wrap(new SubscriptionFunc());
+        return new ReplaySubject(onSubscribe, subscriptionManager, state);
     }
 
-    private static final class DelegateSubscriptionFunc implements OnSubscribeFunc
-    {
-        private Func1, ? extends Subscription> delegate = null;
+    private static class ReplayState {
+        // single-producer, multi-consumer
+        final History history = new History();
+        // each Observer is tracked here for what events they have received
+        final ConcurrentHashMap, Link> replayState = new ConcurrentHashMap, Link>();
+    }
 
-        public void wrap(Func1, ? extends Subscription> delegate)
-        {
-            if (this.delegate != null) {
-                throw new UnsupportedOperationException("delegate already set");
-            }
-            this.delegate = delegate;
-        }
+    private final SubjectSubscriptionManager subscriptionManager;
+    private final ReplayState state;
 
-        @Override
-        public Subscription onSubscribe(Observer observer)
-        {
-            return delegate.call(observer);
-        }
+    protected ReplaySubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManager subscriptionManager, ReplayState state) {
+        super(onSubscribe);
+        this.subscriptionManager = subscriptionManager;
+        this.state = state;
     }
 
-    private class SubscriptionFunc implements Func1, Subscription>
-    {
-        @Override
-        public Subscription call(Observer observer) {
-            int item = 0;
-            Subscription subscription;
-
-            for (;;) {
-                while (item < history.size()) {
-                    observer.onNext(history.get(item++));
+    @Override
+    public void onCompleted() {
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                state.history.add(new Notification());
+                for (Observer o : observers) {
+                    replayObserverToTail(o);
                 }
+            }
+        });
+    }
 
-                synchronized (subscriptions) {
-                    if (item < history.size()) {
-                        continue;
-                    }
-
-                    if (exception != null) {
-                        observer.onError(exception);
-                        return Subscriptions.empty();
-                    }
-                    if (isDone) {
-                        observer.onCompleted();
-                        return Subscriptions.empty();
-                    }
-
-                    subscription = new RepeatSubjectSubscription();
-                    subscriptions.put(subscription, observer);
-                    break;
+    @Override
+    public void onError(final Throwable e) {
+        subscriptionManager.terminate(new Action1>>() {
+
+            @Override
+            public void call(Collection> observers) {
+                state.history.add(new Notification(e));
+                for (Observer o : observers) {
+                    replayObserverToTail(o);
                 }
             }
+        });
+    }
 
-            return subscription;
+    @Override
+    public void onNext(T v) {
+        state.history.add(new Notification(v));
+        for (Observer o : subscriptionManager.snapshotOfObservers()) {
+            replayObserverToTail(o);
         }
     }
 
-    private class RepeatSubjectSubscription implements Subscription
-    {
-        @Override
-        public void unsubscribe()
-        {
-            synchronized (subscriptions) {
-                subscriptions.remove(this);
-            }
+    private void replayObserverToTail(Observer observer) {
+        Link lastEmittedLink = state.replayState.get(observer);
+        if (lastEmittedLink != null) {
+            Link l = replayObserverFromLink(lastEmittedLink, observer);
+            state.replayState.put(observer, l);
+        } else {
+            throw new IllegalStateException("failed to find lastEmittedLink for: " + observer);
         }
     }
 
-    @Override
-    public void onCompleted()
-    {
-        synchronized (subscriptions) {
-            isDone = true;
-            for (Observer observer : new ArrayList>(subscriptions.values())) {
-                observer.onCompleted();
-            }
-            subscriptions.clear();
+    private static  Link replayObserverFromLink(Link l, Observer observer) {
+        while (l.nextLink != null) {
+            // forward to next link
+            l = l.nextLink;
+            // emit value on this link
+            l.n.accept(observer);
         }
+
+        return l;
     }
 
-    @Override
-    public void onError(Throwable e)
-    {
-        synchronized (subscriptions) {
-            if (isDone) {
-                return;
-            }
-            isDone = true;
-            exception = e;
-            for (Observer observer : new ArrayList>(subscriptions.values())) {
-                observer.onError(e);
-            }
-            subscriptions.clear();
+    /**
+     * NOT thread-safe for multi-writer. Assumes single-writer.
+     * Is thread-safe for multi-reader.
+     * 
+     * @param 
+     */
+    private static class History {
+        private final Link head = new Link(null);
+        private volatile Link tail = head;
+
+        public Link add(Notification n) {
+            tail = tail.addNext(n);
+            return tail;
         }
     }
 
-    @Override
-    public void onNext(T args)
-    {
-        synchronized (subscriptions) {
-            if (isDone) {
-                return;
-            }
-            history.add(args);
-            for (Observer observer : new ArrayList>(subscriptions.values())) {
-                observer.onNext(args);
+    /**
+     * Very simple linked-list so each Observer retains a reference to the last Link they saw
+     * and can replay forward down the links.
+     * 
+     * Mutation of the list is NOT thread-safe as it expects single-writer.
+     * 
+     * Reading of the list is thread-safe as 'Notification' is final and 'nextLink' is volatile.
+     * 
+     * @param 
+     */
+    private static class Link {
+        private final Notification n;
+        private volatile Link nextLink;
+
+        private Link(Notification n) {
+            this.n = n;
+        }
+
+        public Link addNext(Notification n) {
+            if (nextLink != null) {
+                throw new IllegalStateException("Link is already set");
             }
+            nextLink = new Link(n);
+            return nextLink;
         }
+
     }
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
new file mode 100644
index 0000000000..ab12e94205
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -0,0 +1,187 @@
+/**
+ * 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.subjects;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.operators.SafeObservableSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action1;
+
+/* package */class SubjectSubscriptionManager {
+
+    private AtomicReference> state = new AtomicReference>(new State());
+
+    /**
+     * 
+     * @param onSubscribe
+     *            Always runs at the beginning of 'subscribe' regardless of terminal state.
+     * @param onTerminated
+     *            Only runs if Subject is in terminal state and the Observer ends up not being registered.
+     * @return
+     */
+    public OnSubscribeFunc getOnSubscribeFunc(final Action1> onSubscribe, final Action1> onTerminated) {
+        return new OnSubscribeFunc() {
+            @Override
+            public Subscription onSubscribe(Observer observer) {
+                // invoke onSubscribe logic 
+                if (onSubscribe != null) {
+                    onSubscribe.call(observer);
+                }
+
+                State current = null;
+                State newState = null;
+                boolean addedObserver = false;
+                Subscription s;
+                do {
+                    current = state.get();
+                    if (current.terminated) {
+                        // we are terminated so don't need to do anything
+                        s = Subscriptions.empty();
+                        addedObserver = false;
+                        // break out and don't try to modify state
+                        newState = current;
+                        // wait for termination to complete if 
+                        try {
+                            current.terminationLatch.await();
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException("Interrupted waiting for termination.", e);
+                        }
+                        break;
+                    } else {
+                        final SafeObservableSubscription subscription = new SafeObservableSubscription();
+                        s = subscription;
+                        addedObserver = true;
+                        subscription.wrap(new Subscription() {
+                            @Override
+                            public void unsubscribe() {
+                                State current;
+                                State newState;
+                                do {
+                                    current = state.get();
+                                    // on unsubscribe remove it from the map of outbound observers to notify
+                                    newState = current.removeObserver(subscription);
+                                } while (!state.compareAndSet(current, newState));
+                            }
+                        });
+
+                        // on subscribe add it to the map of outbound observers to notify
+                        newState = current.addObserver(subscription, observer);
+                    }
+                } while (!state.compareAndSet(current, newState));
+
+                /**
+                 * Whatever happened above, if we are terminated we run `onTerminated`
+                 */
+                if (newState.terminated && !addedObserver) {
+                    onTerminated.call(observer);
+                }
+
+                return s;
+            }
+
+        };
+    }
+
+    protected void terminate(Action1>> onTerminate) {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.terminated) {
+                // already terminated so do nothing
+                return;
+            } else {
+                newState = current.terminate();
+            }
+        } while (!state.compareAndSet(current, newState));
+
+        /*
+         * if we get here then we won setting the state to terminated
+         * and have a deterministic set of Observers to emit to (concurrent subscribes
+         * will have failed and will try again and see we are term
+         * inated)
+         */
+        try {
+            onTerminate.call(newState.observers.values());
+        } finally {
+            // mark that termination is completed
+            newState.terminationLatch.countDown();
+        }
+    }
+
+    /**
+     * Current snapshot of 'state.observers.keySet()' so that concurrent modifications aren't included.
+     * 
+     * This makes it behave deterministically in a single-threaded execution when nesting subscribes.
+     * 
+     * In multi-threaded execution it will cause new subscriptions to wait until the following onNext instead
+     * of possibly being included in the current onNext iteration.
+     * 
+     * @return List>
+     */
+    public Collection> snapshotOfObservers() {
+        // we don't need to copy since state is immutable
+        return state.get().observers.values();
+    }
+
+    protected static class State {
+        final boolean terminated;
+        final CountDownLatch terminationLatch;
+        final Map> observers;
+
+        private State(boolean isTerminated, CountDownLatch terminationLatch, Map> observers) {
+            this.terminationLatch = terminationLatch;
+            this.terminated = isTerminated;
+            this.observers = Collections.unmodifiableMap(observers);
+        }
+
+        State() {
+            this.terminated = false;
+            this.terminationLatch = null;
+            this.observers = Collections.emptyMap();
+        }
+
+        public State terminate() {
+            if (terminated) {
+                throw new IllegalStateException("Already terminated.");
+            }
+            return new State(true, new CountDownLatch(1), observers);
+        }
+
+        public State addObserver(Subscription s, Observer observer) {
+            Map> newMap = new HashMap>();
+            newMap.putAll(observers);
+            newMap.put(s, observer);
+            return new State(terminated, terminationLatch, newMap);
+        }
+
+        public State removeObserver(Subscription s) {
+            Map> newMap = new HashMap>(observers);
+            newMap.remove(s);
+            return new State(terminated, terminationLatch, newMap);
+        }
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java b/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java
deleted file mode 100644
index 0aaf498bc7..0000000000
--- a/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java
+++ /dev/null
@@ -1,186 +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.subjects;
-
-import static org.junit.Assert.*;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-
-/* package */class UnsubscribeTester {
-
-    /*
-     * This is purposefully package-only so it does not leak into the public API outside of this package.
-     * 
-     * This package is implementation details and not part of the Javadocs and thus can change without breaking backwards compatibility.
-     * 
-     * benjchristensen => I'm procrastinating the decision of where and how these types of classes (see rx.operators.OperatorTester) should exist.
-     * If they are only for internal implementations then I don't want them as part of the API.
-     * If they are truly useful for everyone to use then an "rx.testing" package may make sense.
-     */
-
-    private boolean isDone = false;
-    private Subscription subscription;
-
-    public UnsubscribeTester() {
-    }
-
-    /**
-     * Tests the unsubscription semantics of an observable.
-     * 
-     * @param provider
-     *            Function that when called provides an instance of the observable being tested
-     * @param generateOnCompleted
-     *            Causes an observer generated by @param provider to generate an onCompleted event. Null to not test onCompleted.
-     * @param generateOnError
-     *            Causes an observer generated by @param provider to generate an onError event. Null to not test onError.
-     * @param generateOnNext
-     *            Causes an observer generated by @param provider to generate an onNext event. Null to not test onNext.
-     * @param 
-     *            The type of object passed by the Observable
-     */
-    public static > void test(Func0 provider, Action1 generateOnCompleted, Action1 generateOnError, Action1 generateOnNext)
-    {
-        if (generateOnCompleted != null) {
-            O observable = provider.call();
-            UnsubscribeTester tester1 = createOnCompleted(observable);
-            UnsubscribeTester tester2 = createOnCompleted(observable);
-            generateOnCompleted.call(observable);
-            tester1.assertPassed();
-            tester2.assertPassed();
-        }
-        if (generateOnError != null) {
-            O observable = provider.call();
-            UnsubscribeTester tester1 = createOnError(observable);
-            UnsubscribeTester tester2 = createOnError(observable);
-            generateOnError.call(observable);
-            tester1.assertPassed();
-            tester2.assertPassed();
-        }
-        if (generateOnNext != null) {
-            O observable = provider.call();
-            UnsubscribeTester tester1 = createOnNext(observable);
-            UnsubscribeTester tester2 = createOnNext(observable);
-            generateOnNext.call(observable);
-            tester1.assertPassed();
-            tester2.assertPassed();
-        }
-    }
-
-    private static  UnsubscribeTester createOnCompleted(Observable observable)
-    {
-        final UnsubscribeTester test = new UnsubscribeTester();
-        test.setSubscription(observable.subscribe(new Observer()
-        {
-            @Override
-            public void onCompleted()
-            {
-                test.doUnsubscribe("onCompleted");
-            }
-
-            @Override
-            public void onError(Throwable e)
-            {
-                test.gotEvent("onError");
-            }
-
-            @Override
-            public void onNext(T args)
-            {
-                test.gotEvent("onNext");
-            }
-        }));
-        return test;
-    }
-
-    private static  UnsubscribeTester createOnError(Observable observable)
-    {
-        final UnsubscribeTester test = new UnsubscribeTester();
-        test.setSubscription(observable.subscribe(new Observer()
-        {
-            @Override
-            public void onCompleted()
-            {
-                test.gotEvent("onCompleted");
-            }
-
-            @Override
-            public void onError(Throwable e)
-            {
-                test.doUnsubscribe("onError");
-            }
-
-            @Override
-            public void onNext(T args)
-            {
-                test.gotEvent("onNext");
-            }
-        }));
-        return test;
-    }
-
-    private static  UnsubscribeTester createOnNext(Observable observable)
-    {
-        final UnsubscribeTester test = new UnsubscribeTester();
-        test.setSubscription(observable.subscribe(new Observer()
-        {
-            @Override
-            public void onCompleted()
-            {
-                test.gotEvent("onCompleted");
-            }
-
-            @Override
-            public void onError(Throwable e)
-            {
-                test.gotEvent("onError");
-            }
-
-            @Override
-            public void onNext(T args)
-            {
-                test.doUnsubscribe("onNext");
-            }
-        }));
-        return test;
-    }
-
-    private void setSubscription(Subscription subscription)
-    {
-        this.subscription = subscription;
-    }
-
-    private void gotEvent(String event)
-    {
-        assertFalse("received " + event + " after unsubscribe", isDone);
-    }
-
-    private void doUnsubscribe(String event)
-    {
-        gotEvent(event);
-        if (subscription != null) {
-            isDone = true;
-            subscription.unsubscribe();
-        }
-    }
-
-    private void assertPassed()
-    {
-        assertTrue("expected notification was received", isDone);
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
index b483b9c99f..7958d87439 100644
--- a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -172,29 +172,6 @@ public void testUnsubscribeBeforeCompleted() {
         verify(aObserver, Mockito.never()).onCompleted();
     }
 
-    @Test
-    public void testUnsubscribe() {
-        UnsubscribeTester.test(
-                new Func0>() {
-                    @Override
-                    public AsyncSubject call() {
-                        return AsyncSubject.create();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(AsyncSubject DefaultSubject) {
-                        DefaultSubject.onCompleted();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(AsyncSubject DefaultSubject) {
-                        DefaultSubject.onError(new Throwable());
-                    }
-                },
-                null
-                );
-    }
-
     @Test
     public void testEmptySubjectCompleted() {
         AsyncSubject subject = AsyncSubject.create();
@@ -215,7 +192,7 @@ public void testEmptySubjectCompleted() {
     /**
      * Can receive timeout if subscribe never receives an onError/onCompleted ... which reveals a race condition.
      */
-    @Test
+    @Test(timeout=10000)
     public void testSubscribeCompletionRaceCondition() {
         /*
          * With non-threadsafe code this fails most of the time on my dev laptop and is non-deterministic enough
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 57958c108f..19badb2d95 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -24,16 +24,14 @@
 
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
 
 public class BehaviorSubjectTest {
 
     private final Throwable testException = new Throwable();
 
     @Test
-    public void testThatObserverReceivesDefaultValueIfNothingWasPublished() {
-        BehaviorSubject subject = BehaviorSubject.createWithDefaultValue("default");
+    public void testThatObserverReceivesDefaultValueAndSubsequentEvents() {
+        BehaviorSubject subject = BehaviorSubject.create("default");
 
         @SuppressWarnings("unchecked")
         Observer aObserver = mock(Observer.class);
@@ -52,7 +50,7 @@ public void testThatObserverReceivesDefaultValueIfNothingWasPublished() {
     }
 
     @Test
-    public void testThatObserverDoesNotReceiveDefaultValueIfSomethingWasPublished() {
+    public void testThatObserverReceivesLatestAndThenSubsequentEvents() {
         BehaviorSubject subject = BehaviorSubject.create("default");
 
         subject.onNext("one");
@@ -73,7 +71,7 @@ public void testThatObserverDoesNotReceiveDefaultValueIfSomethingWasPublished()
     }
 
     @Test
-    public void testCompleted() {
+    public void testSubscribeThenOnComplete() {
         BehaviorSubject subject = BehaviorSubject.create("default");
 
         @SuppressWarnings("unchecked")
@@ -89,6 +87,39 @@ public void testCompleted() {
         verify(aObserver, times(1)).onCompleted();
     }
 
+    @Test
+    public void testSubscribeToCompletedOnlyEmitsOnComplete() {
+        BehaviorSubject subject = BehaviorSubject.create("default");
+        subject.onNext("one");
+        subject.onCompleted();
+
+        @SuppressWarnings("unchecked")
+        Observer aObserver = mock(Observer.class);
+        subject.subscribe(aObserver);
+
+        verify(aObserver, never()).onNext("default");
+        verify(aObserver, never()).onNext("one");
+        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
+        verify(aObserver, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSubscribeToErrorOnlyEmitsOnError() {
+        BehaviorSubject subject = BehaviorSubject.create("default");
+        subject.onNext("one");
+        RuntimeException re = new RuntimeException("test error");
+        subject.onError(re);
+
+        @SuppressWarnings("unchecked")
+        Observer aObserver = mock(Observer.class);
+        subject.subscribe(aObserver);
+
+        verify(aObserver, never()).onNext("default");
+        verify(aObserver, never()).onNext("one");
+        verify(aObserver, times(1)).onError(re);
+        verify(aObserver, never()).onCompleted();
+    }
+
     @Test
     public void testCompletedStopsEmittingData() {
         BehaviorSubject channel = BehaviorSubject.create(2013);
@@ -136,7 +167,7 @@ public void testCompletedStopsEmittingData() {
     }
 
     @Test
-    public void testCompletedAfterError() {
+    public void testCompletedAfterErrorIsNotSent() {
         BehaviorSubject subject = BehaviorSubject.create("default");
 
         @SuppressWarnings("unchecked")
@@ -151,32 +182,8 @@ public void testCompletedAfterError() {
         verify(aObserver, times(1)).onNext("default");
         verify(aObserver, times(1)).onNext("one");
         verify(aObserver, times(1)).onError(testException);
+        verify(aObserver, never()).onNext("two");
+        verify(aObserver, never()).onCompleted();
     }
 
-    @Test
-    public void testUnsubscribe() {
-        UnsubscribeTester.test(
-                new Func0>() {
-                    @Override
-                    public BehaviorSubject call() {
-                        return BehaviorSubject.create("default");
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(BehaviorSubject DefaultSubject) {
-                        DefaultSubject.onCompleted();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(BehaviorSubject DefaultSubject) {
-                        DefaultSubject.onError(new Throwable());
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(BehaviorSubject DefaultSubject) {
-                        DefaultSubject.onNext("one");
-                    }
-                }
-                );
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index 5e9cc2790f..518d9b7b74 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -209,33 +209,6 @@ private void assertObservedUntilTwo(Observer aObserver) {
         verify(aObserver, Mockito.never()).onCompleted();
     }
 
-    @Test
-    public void testUnsubscribe() {
-        UnsubscribeTester.test(
-                new Func0>() {
-                    @Override
-                    public PublishSubject call() {
-                        return PublishSubject.create();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(PublishSubject DefaultSubject) {
-                        DefaultSubject.onCompleted();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(PublishSubject DefaultSubject) {
-                        DefaultSubject.onError(new Throwable());
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(PublishSubject DefaultSubject) {
-                        DefaultSubject.onNext("one");
-                    }
-                }
-                );
-    }
-
     @Test
     public void testNestedSubscribe() {
         final PublishSubject s = PublishSubject.create();
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java
new file mode 100644
index 0000000000..afe46ee744
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java
@@ -0,0 +1,311 @@
+package rx.subjects;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action1;
+
+public class ReplaySubjectPerformanceAndConcurrencyTest {
+
+    public static void main(String args[]) {
+        try {
+            for (int i = 0; i < 100; i++) {
+                new ReplaySubjectPerformanceAndConcurrencyTest().testSubscribeCompletionRaceCondition();
+                new ReplaySubjectPerformanceAndConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
+                new ReplaySubjectPerformanceAndConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test(timeout = 4000)
+    public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException {
+        final ReplaySubject replay = ReplaySubject.create();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribeFunc() {
+
+                    @Override
+                    public Subscription onSubscribe(Observer o) {
+                        System.out.println("********* Start Source Data ***********");
+                        for (long l = 1; l <= 10000; l++) {
+                            o.onNext(l);
+                        }
+                        System.out.println("********* Finished Source Data ***********");
+                        o.onCompleted();
+                        return Subscriptions.empty();
+                    }
+                }).subscribe(replay);
+            }
+        });
+        source.start();
+
+        long v = replay.toBlockingObservable().last();
+        assertEquals(10000, v);
+
+        // it's been played through once so now it will all be replays
+        final CountDownLatch slowLatch = new CountDownLatch(1);
+        Thread slowThread = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observer slow = new Observer() {
+
+                    @Override
+                    public void onCompleted() {
+                        System.out.println("*** Slow Observer completed");
+                        slowLatch.countDown();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                    }
+
+                    @Override
+                    public void onNext(Long args) {
+                        if (args == 1) {
+                            System.out.println("*** Slow Observer STARTED");
+                        }
+                        try {
+                            if (args % 10 == 0) {
+                                Thread.sleep(1);
+                            }
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                };
+                replay.subscribe(slow);
+                try {
+                    slowLatch.await();
+                } catch (InterruptedException e1) {
+                    e1.printStackTrace();
+                }
+            }
+        });
+        slowThread.start();
+
+        Thread fastThread = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                final CountDownLatch fastLatch = new CountDownLatch(1);
+                Observer fast = new Observer() {
+
+                    @Override
+                    public void onCompleted() {
+                        System.out.println("*** Fast Observer completed");
+                        fastLatch.countDown();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                    }
+
+                    @Override
+                    public void onNext(Long args) {
+                        if (args == 1) {
+                            System.out.println("*** Fast Observer STARTED");
+                        }
+                    }
+                };
+                replay.subscribe(fast);
+                try {
+                    fastLatch.await();
+                } catch (InterruptedException e1) {
+                    e1.printStackTrace();
+                }
+            }
+        });
+        fastThread.start();
+        fastThread.join();
+
+        // slow should not yet be completed when fast completes
+        assertEquals(1, slowLatch.getCount());
+
+        slowThread.join();
+    }
+
+    @Test
+    public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException {
+        final ReplaySubject replay = ReplaySubject.create();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribeFunc() {
+
+                    @Override
+                    public Subscription onSubscribe(Observer o) {
+                        System.out.println("********* Start Source Data ***********");
+                        for (long l = 1; l <= 10000; l++) {
+                            o.onNext(l);
+                        }
+                        System.out.println("********* Finished Source Data ***********");
+                        o.onCompleted();
+                        return Subscriptions.empty();
+                    }
+                }).subscribe(replay);
+            }
+        });
+
+        // used to collect results of each thread
+        final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList>());
+        final List threads = Collections.synchronizedList(new ArrayList());
+
+        for (int i = 1; i <= 200; i++) {
+            final int count = i;
+            if (count == 20) {
+                // start source data after we have some already subscribed
+                // and while others are in process of subscribing
+                source.start();
+            }
+            if (count == 100) {
+                // wait for source to finish then keep adding after it's done
+                source.join();
+            }
+            Thread t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    List values = replay.toList().toBlockingObservable().last();
+                    listOfListsOfValues.add(values);
+                    System.out.println("Finished thread: " + count);
+                }
+            });
+            t.start();
+            System.out.println("Started thread: " + i);
+            threads.add(t);
+        }
+
+        // wait for all threads to complete
+        for (Thread t : threads) {
+            t.join();
+        }
+
+        // assert all threads got the same results
+        List sums = new ArrayList();
+        for (List values : listOfListsOfValues) {
+            long v = 0;
+            for (long l : values) {
+                v += l;
+            }
+            sums.add(v);
+        }
+
+        long expected = sums.get(0);
+        boolean success = true;
+        for (long l : sums) {
+            if (l != expected) {
+                success = false;
+                System.out.println("FAILURE => Expected " + expected + " but got: " + l);
+            }
+        }
+
+        if (success) {
+            System.out.println("Success! " + sums.size() + " each had the same sum of " + expected);
+        } else {
+            throw new RuntimeException("Concurrency Bug");
+        }
+
+    }
+
+    /**
+     * Can receive timeout if subscribe never receives an onError/onCompleted ... which reveals a race condition.
+     */
+    @Test(timeout = 10000)
+    public void testSubscribeCompletionRaceCondition() {
+        for (int i = 0; i < 50; i++) {
+            final ReplaySubject subject = ReplaySubject.create();
+            final AtomicReference value1 = new AtomicReference();
+
+            subject.subscribe(new Action1() {
+
+                @Override
+                public void call(String t1) {
+                    try {
+                        // simulate a slow observer
+                        Thread.sleep(50);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    value1.set(t1);
+                }
+
+            });
+
+            Thread t1 = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    subject.onNext("value");
+                    subject.onCompleted();
+                }
+            });
+
+            SubjectObserverThread t2 = new SubjectObserverThread(subject);
+            SubjectObserverThread t3 = new SubjectObserverThread(subject);
+            SubjectObserverThread t4 = new SubjectObserverThread(subject);
+            SubjectObserverThread t5 = new SubjectObserverThread(subject);
+
+            t2.start();
+            t3.start();
+            t1.start();
+            t4.start();
+            t5.start();
+            try {
+                t1.join();
+                t2.join();
+                t3.join();
+                t4.join();
+                t5.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            assertEquals("value", value1.get());
+            assertEquals("value", t2.value.get());
+            assertEquals("value", t3.value.get());
+            assertEquals("value", t4.value.get());
+            assertEquals("value", t5.value.get());
+        }
+
+    }
+
+    private static class SubjectObserverThread extends Thread {
+
+        private final ReplaySubject subject;
+        private final AtomicReference value = new AtomicReference();
+
+        public SubjectObserverThread(ReplaySubject subject) {
+            this.subject = subject;
+        }
+
+        @Override
+        public void run() {
+            try {
+                // a timeout exception will happen if we don't get a terminal state 
+                String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlockingObservable().single();
+                value.set(v);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 005b56ba5a..e853944820 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -15,17 +15,20 @@
  */
 package rx.subjects;
 
+import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
 
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
+import rx.schedulers.Schedulers;
 
 public class ReplaySubjectTest {
 
@@ -243,30 +246,90 @@ private void assertObservedUntilTwo(Observer aObserver) {
         verify(aObserver, Mockito.never()).onCompleted();
     }
 
-    @Test
-    public void testUnsubscribe() {
-        UnsubscribeTester.test(
-                new Func0>() {
-                    @Override
-                    public ReplaySubject call() {
-                        return ReplaySubject.create();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(ReplaySubject repeatSubject) {
-                        repeatSubject.onCompleted();
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(ReplaySubject repeatSubject) {
-                        repeatSubject.onError(new Throwable());
-                    }
-                }, new Action1>() {
-                    @Override
-                    public void call(ReplaySubject repeatSubject) {
-                        repeatSubject.onNext("one");
+    @Test(timeout = 2000)
+    public void testNewSubscriberDoesntBlockExisting() throws InterruptedException {
+
+        final AtomicReference lastValueForObserver1 = new AtomicReference();
+        Observer observer1 = new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String v) {
+                System.out.println("observer1: " + v);
+                lastValueForObserver1.set(v);
+            }
+
+        };
+
+        final AtomicReference lastValueForObserver2 = new AtomicReference();
+        final CountDownLatch oneReceived = new CountDownLatch(1);
+        final CountDownLatch makeSlow = new CountDownLatch(1);
+        final CountDownLatch completed = new CountDownLatch(1);
+        Observer observer2 = new Observer() {
+
+            @Override
+            public void onCompleted() {
+                completed.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String v) {
+                System.out.println("observer2: " + v);
+                if (v.equals("one")) {
+                    oneReceived.countDown();
+                } else {
+                    try {
+                        makeSlow.await();
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
                     }
+                    lastValueForObserver2.set(v);
                 }
-                );
+            }
+
+        };
+
+        ReplaySubject subject = ReplaySubject.create();
+        Subscription s1 = subject.subscribe(observer1);
+        subject.onNext("one");
+        assertEquals("one", lastValueForObserver1.get());
+        subject.onNext("two");
+        assertEquals("two", lastValueForObserver1.get());
+
+        Subscription s2 = subject.observeOn(Schedulers.newThread()).subscribe(observer2);
+
+        System.out.println("before waiting for one");
+        
+        // wait until observer2 starts having replay occur
+        oneReceived.await();
+        
+        System.out.println("after waiting for one");
+        
+        subject.onNext("three");
+        // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet 
+        assertEquals("three", lastValueForObserver1.get());
+        subject.onCompleted();
+
+        // release 
+        makeSlow.countDown();
+        completed.await();
+        // all of them should be emitted with the last being "three"
+        assertEquals("three", lastValueForObserver2.get());
+
     }
+
 }

From dba5de963a8a04445feb09d533998aef4a7227f2 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 21 Dec 2013 21:01:39 -0800
Subject: [PATCH 110/441] License Header and Separate out Perf Tests

---
 ...java => ReplaySubjectConcurrencyTest.java} | 23 +++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)
 rename rxjava-core/src/test/java/rx/subjects/{ReplaySubjectPerformanceAndConcurrencyTest.java => ReplaySubjectConcurrencyTest.java} (91%)

diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
similarity index 91%
rename from rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java
rename to rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index afe46ee744..60ff4f0cfd 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectPerformanceAndConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -1,3 +1,18 @@
+/**
+ * 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.subjects;
 
 import static org.junit.Assert.*;
@@ -18,14 +33,14 @@
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action1;
 
-public class ReplaySubjectPerformanceAndConcurrencyTest {
+public class ReplaySubjectConcurrencyTest {
 
     public static void main(String args[]) {
         try {
             for (int i = 0; i < 100; i++) {
-                new ReplaySubjectPerformanceAndConcurrencyTest().testSubscribeCompletionRaceCondition();
-                new ReplaySubjectPerformanceAndConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
-                new ReplaySubjectPerformanceAndConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
+                new ReplaySubjectConcurrencyTest().testSubscribeCompletionRaceCondition();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
             }
         } catch (InterruptedException e) {
             e.printStackTrace();

From a144b0e20a44a4d84ec58ccf2d213672a4aacd75 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 21 Dec 2013 22:34:36 -0800
Subject: [PATCH 111/441] Refactor for Performance

- previous commit got non-blocking working but perf tests showed it slow
- this commit retains non-blocking but surpasses master branch performance

Master branch: 11,947,459 ops/sec
This commit: 16,151,174 ops/sec
---
 .../main/java/rx/subjects/AsyncSubject.java   |  17 +-
 .../java/rx/subjects/BehaviorSubject.java     |  17 +-
 .../main/java/rx/subjects/PublishSubject.java |  17 +-
 .../main/java/rx/subjects/ReplaySubject.java  | 141 ++++++++--------
 .../subjects/SubjectSubscriptionManager.java  |  46 ++++--
 .../rx/subjects/SubjectPerformanceTests.java  | 150 ++++++++++++++++++
 6 files changed, 292 insertions(+), 96 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java

diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 01062870da..6e9dce1d35 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -20,6 +20,7 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.util.functions.Action1;
 
 /**
@@ -63,20 +64,20 @@ public static  AsyncSubject create() {
                  * 
                  * This will always run, even if Subject is in terminal state.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         // nothing to do if not terminated
                     }
                 },
                 /**
                  * This function executes if the Subject is terminated.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         // we want the last value + completed so add this extra logic 
                         // to send onCompleted if the last value is an onNext
                         emitValueToObserver(lastNotification.get(), o);
@@ -104,10 +105,10 @@ protected AsyncSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManage
 
     @Override
     public void onCompleted() {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 for (Observer o : observers) {
                     emitValueToObserver(lastNotification.get(), o);
                 }
@@ -117,10 +118,10 @@ public void call(Collection> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 lastNotification.set(new Notification(e));
                 for (Observer o : observers) {
                     emitValueToObserver(lastNotification.get(), o);
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 723acb154d..738462321c 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -20,6 +20,7 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.util.functions.Action1;
 
 /**
@@ -95,10 +96,10 @@ public static  BehaviorSubject create(T defaultValue) {
                  * 
                  * This will always run, even if Subject is in terminal state.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         /*
                          * When we subscribe we always emit the latest value to the observer.
                          * 
@@ -113,10 +114,10 @@ public void call(Observer o) {
                 /**
                  * This function executes if the Subject is terminated before subscription occurs.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         /*
                          * If we are already terminated, or termination happens while trying to subscribe
                          * this will be invoked and we emit whatever the last terminal value was.
@@ -139,10 +140,10 @@ protected BehaviorSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionMan
 
     @Override
     public void onCompleted() {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 lastNotification.set(new Notification());
                 for (Observer o : observers) {
                     o.onCompleted();
@@ -153,10 +154,10 @@ public void call(Collection> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 lastNotification.set(new Notification(e));
                 for (Observer o : observers) {
                     o.onError(e);
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 0f350e6b85..2803b11723 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -20,6 +20,7 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.util.functions.Action1;
 
 /**
@@ -58,20 +59,20 @@ public static  PublishSubject create() {
                  * 
                  * This will always run, even if Subject is in terminal state.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         // nothing onSubscribe unless in terminal state which is the next function
                     }
                 },
                 /**
                  * This function executes if the Subject is terminated before subscription occurs.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         /*
                          * If we are already terminated, or termination happens while trying to subscribe
                          * this will be invoked and we emit whatever the last terminal value was.
@@ -94,10 +95,10 @@ protected PublishSubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionMana
 
     @Override
     public void onCompleted() {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 lastNotification.set(new Notification());
                 for (Observer o : observers) {
                     o.onCompleted();
@@ -108,10 +109,10 @@ public void call(Collection> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
+            public void call(Collection> observers) {
                 lastNotification.set(new Notification(e));
                 for (Observer o : observers) {
                     o.onError(e);
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 3af8f85835..3dcd869ff3 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -15,11 +15,15 @@
  */
 package rx.subjects;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Notification;
 import rx.Observer;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.util.functions.Action1;
 
 /**
@@ -31,7 +35,7 @@
  * 
    
  * 
     {@code
 
- * eplaySubject subject = ReplaySubject.create();
+ * ReplaySubject subject = ReplaySubject.create();
   subject.onNext("one");
   subject.onNext("two");
   subject.onNext("three");
@@ -59,26 +63,26 @@ public static  ReplaySubject create() {
                  * 
                  * This will always run, even if Subject is in terminal state.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         // replay history for this observer using the subscribing thread
-                        Link last = replayObserverFromLink(state.history.head, o);
+                        int lastIndex = replayObserverFromIndex(state.history, 0, o);
 
                         // now that it is caught up add to observers
-                        state.replayState.put(o, last);
+                        state.replayState.put(o, lastIndex);
                     }
                 },
                 /**
                  * This function executes if the Subject is terminated.
                  */
-                new Action1>() {
+                new Action1>() {
 
                     @Override
-                    public void call(Observer o) {
+                    public void call(SubjectObserver o) {
                         // we will finish replaying if there is anything left
-                        replayObserverFromLink(state.replayState.get(o), o);
+                        replayObserverFromIndex(state.history, state.replayState.get(o), o);
                     }
                 });
 
@@ -89,7 +93,7 @@ private static class ReplayState {
         // single-producer, multi-consumer
         final History history = new History();
         // each Observer is tracked here for what events they have received
-        final ConcurrentHashMap, Link> replayState = new ConcurrentHashMap, Link>();
+        final ConcurrentHashMap, Integer> replayState = new ConcurrentHashMap, Integer>();
     }
 
     private final SubjectSubscriptionManager subscriptionManager;
@@ -103,13 +107,15 @@ protected ReplaySubject(OnSubscribeFunc onSubscribe, SubjectSubscriptionManag
 
     @Override
     public void onCompleted() {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
-                state.history.add(new Notification());
-                for (Observer o : observers) {
-                    replayObserverToTail(o);
+            public void call(Collection> observers) {
+                state.history.complete(new Notification());
+                for (SubjectObserver o : observers) {
+                    if (caughtUp(o)) {
+                        o.onCompleted();
+                    }
                 }
             }
         });
@@ -117,13 +123,15 @@ public void call(Collection> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        subscriptionManager.terminate(new Action1>>() {
+        subscriptionManager.terminate(new Action1>>() {
 
             @Override
-            public void call(Collection> observers) {
-                state.history.add(new Notification(e));
-                for (Observer o : observers) {
-                    replayObserverToTail(o);
+            public void call(Collection> observers) {
+                state.history.complete(new Notification(e));
+                for (SubjectObserver o : observers) {
+                    if (caughtUp(o)) {
+                        o.onError(e);
+                    }
                 }
             }
         });
@@ -131,28 +139,52 @@ public void call(Collection> observers) {
 
     @Override
     public void onNext(T v) {
-        state.history.add(new Notification(v));
-        for (Observer o : subscriptionManager.snapshotOfObservers()) {
-            replayObserverToTail(o);
+        if (state.history.terminalValue.get() != null) {
+            return;
+        }
+        state.history.next(v);
+        for (SubjectObserver o : subscriptionManager.snapshotOfObservers()) {
+            if (caughtUp(o)) {
+                o.onNext(v);
+            }
         }
     }
 
-    private void replayObserverToTail(Observer observer) {
-        Link lastEmittedLink = state.replayState.get(observer);
+    /*
+     * This is not very elegant but resulted in non-trivial performance improvement by
+     * eliminating the 'replay' code-path on the normal fast-path of emitting values.
+     * 
+     * With this method: 16,151,174 ops/sec
+     * Without: 8,632,358 ops/sec
+     */
+    private boolean caughtUp(SubjectObserver o) {
+        if (!o.caughtUp) {
+            o.caughtUp = true;
+            replayObserver(o);
+            return false;
+        } else {
+            // it was caught up so proceed the "raw route"
+            return true;
+        }
+    }
+
+    private void replayObserver(SubjectObserver observer) {
+        Integer lastEmittedLink = state.replayState.get(observer);
         if (lastEmittedLink != null) {
-            Link l = replayObserverFromLink(lastEmittedLink, observer);
+            int l = replayObserverFromIndex(state.history, lastEmittedLink, observer);
             state.replayState.put(observer, l);
         } else {
             throw new IllegalStateException("failed to find lastEmittedLink for: " + observer);
         }
     }
 
-    private static  Link replayObserverFromLink(Link l, Observer observer) {
-        while (l.nextLink != null) {
-            // forward to next link
-            l = l.nextLink;
-            // emit value on this link
-            l.n.accept(observer);
+    private static  int replayObserverFromIndex(History history, Integer l, SubjectObserver observer) {
+        while (l < history.index.get()) {
+            observer.onNext(history.list.get(l));
+            l++;
+        }
+        if (history.terminalValue.get() != null) {
+            history.terminalValue.get().accept(observer);
         }
 
         return l;
@@ -165,40 +197,23 @@ private static  Link replayObserverFromLink(Link l, Observer
      * @param 
      */
     private static class History {
-        private final Link head = new Link(null);
-        private volatile Link tail = head;
-
-        public Link add(Notification n) {
-            tail = tail.addNext(n);
-            return tail;
-        }
-    }
-
-    /**
-     * Very simple linked-list so each Observer retains a reference to the last Link they saw
-     * and can replay forward down the links.
-     * 
-     * Mutation of the list is NOT thread-safe as it expects single-writer.
-     * 
-     * Reading of the list is thread-safe as 'Notification' is final and 'nextLink' is volatile.
-     * 
-     * @param 
-     */
-    private static class Link {
-        private final Notification n;
-        private volatile Link nextLink;
-
-        private Link(Notification n) {
-            this.n = n;
-        }
-
-        public Link addNext(Notification n) {
-            if (nextLink != null) {
-                throw new IllegalStateException("Link is already set");
+        private AtomicInteger index = new AtomicInteger(0);
+        private final ArrayList list = new ArrayList();
+        private AtomicReference> terminalValue = new AtomicReference>();
+
+        public boolean next(T n) {
+            if (terminalValue.get() == null) {
+                list.add(n);
+                index.getAndIncrement();
+                return true;
+            } else {
+                return false;
             }
-            nextLink = new Link(n);
-            return nextLink;
         }
 
+        public void complete(Notification n) {
+            terminalValue.set(n);
+        }
     }
+
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index ab12e94205..c3f92b159b 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -20,6 +20,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable.OnSubscribeFunc;
@@ -41,10 +42,11 @@
      *            Only runs if Subject is in terminal state and the Observer ends up not being registered.
      * @return
      */
-    public OnSubscribeFunc getOnSubscribeFunc(final Action1> onSubscribe, final Action1> onTerminated) {
+    public OnSubscribeFunc getOnSubscribeFunc(final Action1> onSubscribe, final Action1> onTerminated) {
         return new OnSubscribeFunc() {
             @Override
-            public Subscription onSubscribe(Observer observer) {
+            public Subscription onSubscribe(Observer actualObserver) {
+                SubjectObserver observer = new SubjectObserver(actualObserver);
                 // invoke onSubscribe logic 
                 if (onSubscribe != null) {
                     onSubscribe.call(observer);
@@ -104,7 +106,7 @@ public void unsubscribe() {
         };
     }
 
-    protected void terminate(Action1>> onTerminate) {
+    protected void terminate(Action1>> onTerminate) {
         State current = null;
         State newState = null;
         do {
@@ -141,7 +143,7 @@ protected void terminate(Action1>> onTerminate) {
      * 
      * @return List>
      */
-    public Collection> snapshotOfObservers() {
+    public Collection> snapshotOfObservers() {
         // we don't need to copy since state is immutable
         return state.get().observers.values();
     }
@@ -149,9 +151,9 @@ public Collection> snapshotOfObservers() {
     protected static class State {
         final boolean terminated;
         final CountDownLatch terminationLatch;
-        final Map> observers;
+        final Map> observers;
 
-        private State(boolean isTerminated, CountDownLatch terminationLatch, Map> observers) {
+        private State(boolean isTerminated, CountDownLatch terminationLatch, Map> observers) {
             this.terminationLatch = terminationLatch;
             this.terminated = isTerminated;
             this.observers = Collections.unmodifiableMap(observers);
@@ -170,18 +172,44 @@ public State terminate() {
             return new State(true, new CountDownLatch(1), observers);
         }
 
-        public State addObserver(Subscription s, Observer observer) {
-            Map> newMap = new HashMap>();
+        public State addObserver(Subscription s, SubjectObserver observer) {
+            Map> newMap = new HashMap>();
             newMap.putAll(observers);
             newMap.put(s, observer);
             return new State(terminated, terminationLatch, newMap);
         }
 
         public State removeObserver(Subscription s) {
-            Map> newMap = new HashMap>(observers);
+            Map> newMap = new HashMap>(observers);
             newMap.remove(s);
             return new State(terminated, terminationLatch, newMap);
         }
     }
 
+    protected static class SubjectObserver implements Observer {
+
+        private final Observer actual;
+        protected volatile boolean caughtUp = false;
+
+        SubjectObserver(Observer actual) {
+            this.actual = actual;
+        }
+
+        @Override
+        public void onCompleted() {
+            this.actual.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            this.actual.onError(e);
+        }
+
+        @Override
+        public void onNext(T v) {
+            this.actual.onNext(v);
+        }
+
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java b/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java
new file mode 100644
index 0000000000..2574b1bcd9
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java
@@ -0,0 +1,150 @@
+/**
+ * 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.subjects;
+
+import rx.Observer;
+import rx.util.functions.Action0;
+
+public class SubjectPerformanceTests {
+
+    private static final int REPETITIONS = 10 * 1000 * 1000;
+    private static final int NUM_PRODUCERS = 1;
+
+    public static void main(String args[]) {
+
+        final SubjectPerformanceTests spt = new SubjectPerformanceTests();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    //                    spt.baseline();
+                    spt.unboundedReplaySubject();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    private void runTest(Action0 action) throws InterruptedException {
+        for (int runNum = 0; runNum < 15; runNum++) {
+            System.gc();
+            Thread.sleep(1000L);
+
+            final long start = System.nanoTime();
+
+            action.call();
+
+            long duration = System.nanoTime() - start;
+            long opsPerSec = (REPETITIONS * NUM_PRODUCERS * 1000L * 1000L * 1000L) / duration;
+            System.out.printf("Run: %d - %,d ops/sec \n",
+                    Integer.valueOf(runNum),
+                    Long.valueOf(opsPerSec));
+        }
+    }
+
+    /**
+     * Baseline ops/second without a subject.
+     * 
+     * Perf along this order of magnitude:
+     * 
+     * Run: 10 - 316,235,532 ops/sec
+     * Run: 11 - 301,886,792 ops/sec
+     * Run: 12 - 310,472,228 ops/sec
+     * Run: 13 - 313,469,797 ops/sec
+     * Run: 14 - 305,380,809 ops/sec
+     */
+    public long baseline() {
+
+        LongObserver o = new LongObserver();
+        for (long l = 0; l < REPETITIONS; l++) {
+            o.onNext(l);
+        }
+        o.onCompleted();
+        return o.sum;
+    }
+
+    /**
+     * ReplaySubject
+     * 
+     * This is testing pass-thru, not replay speed (though it will be storing all of the history).
+     * 
+     * ArrayList with raw values & synchronized access
+     * 
+     * Run: 10 - 11,993,341 ops/sec
+     * Run: 11 - 11,719,523 ops/sec
+     * Run: 12 - 11,965,214 ops/sec
+     * Run: 13 - 11,814,730 ops/sec
+     * Run: 14 - 11,947,459 ops/sec
+     * 
+     * Custom linked list + Notification (failed experiment)
+     * 
+     * Run: 10 - 2,102,785 ops/sec
+     * Run: 11 - 2,109,057 ops/sec
+     * Run: 12 - 2,094,372 ops/sec
+     * Run: 13 - 2,096,183 ops/sec
+     * Run: 14 - 2,107,019 ops/sec
+     * 
+     * Custom linked list + raw values (elegant code ... but another failed experiment)
+     * 
+     * Run: 10 - 5,131,634 ops/sec
+     * Run: 11 - 5,133,114 ops/sec
+     * Run: 12 - 5,080,652 ops/sec
+     * Run: 13 - 5,072,743 ops/sec
+     * Run: 14 - 5,198,813 ops/sec
+     * 
+     * ArrayList with raw values & non-blocking (no synchronization)
+     * 
+     * Run: 10 - 16,069,678 ops/sec
+     * Run: 11 - 15,954,688 ops/sec
+     * Run: 12 - 16,158,874 ops/sec
+     * Run: 13 - 16,209,504 ops/sec
+     * Run: 14 - 16,151,174 ops/sec
+     */
+    public long unboundedReplaySubject() {
+        ReplaySubject s = ReplaySubject.create();
+        LongObserver o = new LongObserver();
+        s.subscribe(o);
+        for (long l = 0; l < REPETITIONS; l++) {
+            s.onNext(l);
+        }
+        s.onCompleted();
+        return o.sum;
+    }
+
+    private static class LongObserver implements Observer {
+
+        long sum = 0;
+
+        @Override
+        public void onCompleted() {
+
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            throw new RuntimeException(e);
+        }
+
+        @Override
+        public void onNext(Long l) {
+            sum += l;
+        }
+    }
+
+}

From 8425eff1d1ae7bdf63ed454518cc8f460320f1d9 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sun, 22 Dec 2013 14:40:01 +0100
Subject: [PATCH 112/441] Performance improvement suggestions.

---
 .../main/java/rx/operators/SafeObserver.java  | 34 +++++--
 .../java/rx/subjects/BehaviorSubject.java     |  2 +-
 .../main/java/rx/subjects/PublishSubject.java |  2 +-
 .../main/java/rx/subjects/ReplaySubject.java  |  4 +-
 .../subjects/SubjectSubscriptionManager.java  | 99 +++++++++++++++----
 5 files changed, 109 insertions(+), 32 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 3e6508dac9..7f32114dbc 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -57,10 +57,25 @@
  */
 public class SafeObserver implements Observer {
 
-    private final Observer actual;
+    private volatile Observer actual;
     private final AtomicBoolean isFinished = new AtomicBoolean(false);
     private final SafeObservableSubscription subscription;
+    /** 
+     * If the observer completes, this is swapped in place of the actual
+     * should avoid the overhead of isFinished.get() on every onNext call. */
+    private static final Observer nopObserver = new Observer() {
+        @Override
+        public void onNext(Object args) {
+        }
+        @Override
+        public void onError(Throwable e) {
+        }
 
+        @Override
+        public void onCompleted() {
+        }
+        
+    };
     public SafeObserver(SafeObservableSubscription subscription, Observer actual) {
         this.subscription = subscription;
         this.actual = actual;
@@ -69,8 +84,10 @@ public SafeObserver(SafeObservableSubscription subscription, Observer
     @Override
     public void onCompleted() {
         if (isFinished.compareAndSet(false, true)) {
+            Observer a = actual;
+            actual = nopObserver;
             try {
-                actual.onCompleted();
+                a.onCompleted();
             } catch (Throwable e) {
                 // handle errors if the onCompleted implementation fails, not just if the Observable fails
                 onError(e);
@@ -83,8 +100,11 @@ public void onCompleted() {
     @Override
     public void onError(Throwable e) {
         if (isFinished.compareAndSet(false, true)) {
+            Observer a = actual;
+            // will prevent onNext from sending a new value after completion
+            actual = nopObserver;
             try {
-                actual.onError(e);
+                a.onError(e);
             } catch (Throwable e2) {
                 if (e2 instanceof OnErrorNotImplementedException) {
                     /**
@@ -117,12 +137,10 @@ public void onError(Throwable e) {
     @Override
     public void onNext(T args) {
         try {
-            if (!isFinished.get()) {
-                actual.onNext(args);
-            }
-        } catch (Throwable e) {
+            actual.onNext(args);
+        } catch (Throwable t) {
             // handle errors if the onNext implementation fails, not just if the Observable fails
-            onError(e);
+            onError(t);
         }
     }
 
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 738462321c..4af0c54b2c 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -173,7 +173,7 @@ public void onNext(T v) {
          * Store the latest value but do not send it. It only gets sent when 'onCompleted' occurs.
          */
         lastNotification.set(new Notification(v));
-        for (Observer o : subscriptionManager.snapshotOfObservers()) {
+        for (Observer o : subscriptionManager.rawSnapshot()) {
             o.onNext(v);
         }
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 2803b11723..daa9dd6636 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -124,7 +124,7 @@ public void call(Collection> observers) {
 
     @Override
     public void onNext(T v) {
-        for (Observer o : subscriptionManager.snapshotOfObservers()) {
+        for (Observer o : subscriptionManager.rawSnapshot()) {
             o.onNext(v);
         }
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 3dcd869ff3..b3ae7ffc50 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -143,7 +143,7 @@ public void onNext(T v) {
             return;
         }
         state.history.next(v);
-        for (SubjectObserver o : subscriptionManager.snapshotOfObservers()) {
+        for (SubjectObserver o : subscriptionManager.rawSnapshot()) {
             if (caughtUp(o)) {
                 o.onNext(v);
             }
@@ -198,7 +198,7 @@ private static  int replayObserverFromIndex(History history, Integer l, Su
      */
     private static class History {
         private AtomicInteger index = new AtomicInteger(0);
-        private final ArrayList list = new ArrayList();
+        private final ArrayList list = new ArrayList(/* 1024 */);
         private AtomicReference> terminalValue = new AtomicReference>();
 
         public boolean next(T n) {
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index c3f92b159b..488470bb20 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -15,12 +15,12 @@
  */
 package rx.subjects;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable.OnSubscribeFunc;
@@ -126,7 +126,8 @@ protected void terminate(Action1>> onTermi
          * inated)
          */
         try {
-            onTerminate.call(newState.observers.values());
+            // had to circumvent type check, we know what the array contains
+            onTerminate.call((Collection)newState.observersList);
         } finally {
             // mark that termination is completed
             newState.terminationLatch.countDown();
@@ -143,46 +144,104 @@ protected void terminate(Action1>> onTermi
      * 
      * @return List>
      */
-    public Collection> snapshotOfObservers() {
-        // we don't need to copy since state is immutable
-        return state.get().observers.values();
+    private Collection> snapshotOfObservers() {
+        // had to circumvent type check, we know what the array contains
+        return (Collection)state.get().observersList;
+    }
+    /**
+     * Returns the array of observers directly.
+     * Don't modify the array!
+     * @return the array of current observers
+     */
+    public SubjectObserver[] rawSnapshot() {
+        return state.get().observers;
     }
 
     protected static class State {
         final boolean terminated;
         final CountDownLatch terminationLatch;
-        final Map> observers;
-
-        private State(boolean isTerminated, CountDownLatch terminationLatch, Map> observers) {
+        final Subscription[] subscriptions;
+        final SubjectObserver[] observers;
+        // to avoid lots of empty arrays
+        final Subscription[] EMPTY_S = new Subscription[0];
+        @SuppressWarnings("rawtypes")
+        // to avoid lots of empty arrays
+        final SubjectObserver[] EMPTY_O = new SubjectObserver[0];
+        @SuppressWarnings("rawtypes")
+        final List> observersList;
+        private State(boolean isTerminated, CountDownLatch terminationLatch, 
+                Subscription[] subscriptions, SubjectObserver[] observers) {
             this.terminationLatch = terminationLatch;
             this.terminated = isTerminated;
-            this.observers = Collections.unmodifiableMap(observers);
+            this.subscriptions = subscriptions;
+            this.observers = observers;
+            this.observersList = Arrays.asList(this.observers);
         }
 
         State() {
             this.terminated = false;
             this.terminationLatch = null;
-            this.observers = Collections.emptyMap();
+            this.subscriptions = EMPTY_S;
+            this.observers = EMPTY_O;
+            observersList = Collections.emptyList();
         }
 
         public State terminate() {
             if (terminated) {
                 throw new IllegalStateException("Already terminated.");
             }
-            return new State(true, new CountDownLatch(1), observers);
+            return new State(true, new CountDownLatch(1), subscriptions, observers);
         }
 
         public State addObserver(Subscription s, SubjectObserver observer) {
-            Map> newMap = new HashMap>();
-            newMap.putAll(observers);
-            newMap.put(s, observer);
-            return new State(terminated, terminationLatch, newMap);
+            int n = this.observers.length;
+            
+            Subscription[] newsubscriptions = Arrays.copyOf(this.subscriptions, n + 1);
+            SubjectObserver[] newobservers = Arrays.copyOf(this.observers, n + 1);
+            
+            newsubscriptions[n] = s;
+            newobservers[n] = observer;
+            
+            return createNewWith(newsubscriptions, newobservers);
+        }
+        private State createNewWith(Subscription[] newsubscriptions, SubjectObserver[] newobservers) {
+            return new State(terminated, terminationLatch, newsubscriptions, newobservers);
         }
 
         public State removeObserver(Subscription s) {
-            Map> newMap = new HashMap>(observers);
-            newMap.remove(s);
-            return new State(terminated, terminationLatch, newMap);
+            // we are empty, nothing to remove
+            if (this.observers.length == 0) {
+                return this;
+            }
+            int n = Math.max(this.observers.length - 1, 1);
+            int copied = 0;
+            Subscription[] newsubscriptions = Arrays.copyOf(this.subscriptions, n);
+            SubjectObserver[] newobservers = Arrays.copyOf(this.observers, n);
+
+            for (int i = 0; i < this.subscriptions.length; i++) {
+                Subscription s0 = this.subscriptions[i];
+                if (s0 != s) {
+                    if (copied == n) {
+                        // if s was not found till the end of the iteration
+                        // we return ourselves since no modification should
+                        // have happened
+                        return this;
+                    }
+                    newsubscriptions[copied] = s0;
+                    newobservers[copied] = this.observers[i];
+                    copied++;
+                }
+            }
+            
+            if (copied == 0) {
+                return createNewWith(EMPTY_S, EMPTY_O);
+            }
+            // if somehow copied less than expected, truncate the arrays
+            // if s is unique, this should never happen
+            if (copied < n) {
+                return createNewWith(Arrays.copyOf(newsubscriptions, copied), Arrays.copyOf(newobservers, copied));
+            }
+            return createNewWith(newsubscriptions, newobservers);
         }
     }
 

From 9561bfcc5e3bd67e3883d4934144ef75ec888bae Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sun, 22 Dec 2013 22:24:28 +0100
Subject: [PATCH 113/441] Added create with initial capacity.

---
 .../main/java/rx/subjects/ReplaySubject.java  | 26 +++++++++++++------
 .../subjects/SubjectSubscriptionManager.java  | 20 ++------------
 2 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index b3ae7ffc50..0546da9a0b 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -50,10 +50,12 @@
  * @param 
  */
 public final class ReplaySubject extends Subject {
-
     public static  ReplaySubject create() {
+        return create(16);
+    }
+    public static  ReplaySubject create(int initialCapacity) {
         final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
-        final ReplayState state = new ReplayState();
+        final ReplayState state = new ReplayState(initialCapacity);
 
         OnSubscribeFunc onSubscribe = subscriptionManager.getOnSubscribeFunc(
                 /**
@@ -91,9 +93,13 @@ public void call(SubjectObserver o) {
 
     private static class ReplayState {
         // single-producer, multi-consumer
-        final History history = new History();
+        final History history;
         // each Observer is tracked here for what events they have received
-        final ConcurrentHashMap, Integer> replayState = new ConcurrentHashMap, Integer>();
+        final ConcurrentHashMap, Integer> replayState;
+        public ReplayState(int initialCapacity) {
+            history = new History(initialCapacity);
+            replayState = new ConcurrentHashMap, Integer>();
+        }
     }
 
     private final SubjectSubscriptionManager subscriptionManager;
@@ -197,10 +203,14 @@ private static  int replayObserverFromIndex(History history, Integer l, Su
      * @param 
      */
     private static class History {
-        private AtomicInteger index = new AtomicInteger(0);
-        private final ArrayList list = new ArrayList(/* 1024 */);
-        private AtomicReference> terminalValue = new AtomicReference>();
-
+        private final AtomicInteger index;
+        private final ArrayList list;
+        private final AtomicReference> terminalValue;
+        public History(int initialCapacity) {
+             index = new AtomicInteger(0);
+             list = new ArrayList(initialCapacity);
+             terminalValue = new AtomicReference>();
+        }
         public boolean next(T n) {
             if (terminalValue.get() == null) {
                 list.add(n);
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 488470bb20..4ea3e6e385 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -15,7 +15,6 @@
  */
 package rx.subjects;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -52,7 +51,7 @@ public Subscription onSubscribe(Observer actualObserver) {
                     onSubscribe.call(observer);
                 }
 
-                State current = null;
+                State current;
                 State newState = null;
                 boolean addedObserver = false;
                 Subscription s;
@@ -107,7 +106,7 @@ public void unsubscribe() {
     }
 
     protected void terminate(Action1>> onTerminate) {
-        State current = null;
+        State current;
         State newState = null;
         do {
             current = state.get();
@@ -133,21 +132,6 @@ protected void terminate(Action1>> onTermi
             newState.terminationLatch.countDown();
         }
     }
-
-    /**
-     * Current snapshot of 'state.observers.keySet()' so that concurrent modifications aren't included.
-     * 
-     * This makes it behave deterministically in a single-threaded execution when nesting subscribes.
-     * 
-     * In multi-threaded execution it will cause new subscriptions to wait until the following onNext instead
-     * of possibly being included in the current onNext iteration.
-     * 
-     * @return List>
-     */
-    private Collection> snapshotOfObservers() {
-        // had to circumvent type check, we know what the array contains
-        return (Collection)state.get().observersList;
-    }
     /**
      * Returns the array of observers directly.
      * Don't modify the array!

From 6d11a551dcf9bb2ed2bd10530b1fbaf6f6380804 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sun, 22 Dec 2013 22:28:45 +0100
Subject: [PATCH 114/441] Added create with initial capacity, minor fix

---
 .../java/rx/subjects/SubjectSubscriptionManager.java | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 4ea3e6e385..ff7033c0c5 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -17,8 +17,6 @@
 
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -126,7 +124,7 @@ protected void terminate(Action1>> onTermi
          */
         try {
             // had to circumvent type check, we know what the array contains
-            onTerminate.call((Collection)newState.observersList);
+            onTerminate.call((Collection)Arrays.asList(newState.observers));
         } finally {
             // mark that termination is completed
             newState.terminationLatch.countDown();
@@ -141,25 +139,22 @@ public SubjectObserver[] rawSnapshot() {
         return state.get().observers;
     }
 
+    @SuppressWarnings("rawtypes")
     protected static class State {
         final boolean terminated;
         final CountDownLatch terminationLatch;
         final Subscription[] subscriptions;
-        final SubjectObserver[] observers;
+        final SubjectObserver[] observers;
         // to avoid lots of empty arrays
         final Subscription[] EMPTY_S = new Subscription[0];
-        @SuppressWarnings("rawtypes")
         // to avoid lots of empty arrays
         final SubjectObserver[] EMPTY_O = new SubjectObserver[0];
-        @SuppressWarnings("rawtypes")
-        final List> observersList;
         private State(boolean isTerminated, CountDownLatch terminationLatch, 
                 Subscription[] subscriptions, SubjectObserver[] observers) {
             this.terminationLatch = terminationLatch;
             this.terminated = isTerminated;
             this.subscriptions = subscriptions;
             this.observers = observers;
-            this.observersList = Arrays.asList(this.observers);
         }
 
         State() {
@@ -167,7 +162,6 @@ private State(boolean isTerminated, CountDownLatch terminationLatch,
             this.terminationLatch = null;
             this.subscriptions = EMPTY_S;
             this.observers = EMPTY_O;
-            observersList = Collections.emptyList();
         }
 
         public State terminate() {

From 14b701d022e4b67d24be5b7751e8836fb6360fbd Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Mon, 23 Dec 2013 19:10:34 +0100
Subject: [PATCH 115/441] Operations Aggregate, Average and Sum with selector

---
 rxjava-core/src/main/java/rx/Observable.java  | 140 +++++++++++
 .../java/rx/operators/OperationAggregate.java | 158 ++++++++++++
 .../java/rx/operators/OperationAverage.java   | 227 +++++++++++++++++
 .../main/java/rx/operators/OperationSum.java  | 229 ++++++++++++++++++
 .../rx/operators/OperationAggregateTest.java  | 140 +++++++++++
 .../rx/operators/OperationAverageTest.java    | 206 +++++++++++++++-
 .../java/rx/operators/OperationSumTest.java   | 205 ++++++++++++++++
 7 files changed, 1304 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperationAggregate.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 04fa8e5132..96c18c4d1c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -32,6 +32,7 @@
 import rx.observables.BlockingObservable;
 import rx.observables.ConnectableObservable;
 import rx.observables.GroupedObservable;
+import rx.operators.OperationAggregate;
 import rx.operators.OperationAll;
 import rx.operators.OperationAmb;
 import rx.operators.OperationAny;
@@ -4118,6 +4119,54 @@ public static Observable sumDoubles(Observable source) {
         return OperationSum.sumDoubles(source);
     }
 
+        /**
+     * Create an Observable that extracts integer values from this Observable via
+     * the provided function and computes the integer sum of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an integer from this Observable
+     * @return an Observable that extracts integer values from this Observable via
+     * the provided function and computes the integer sum of the value sequence.
+     */
+    public Observable sumInteger(Func1 valueExtractor) {
+        return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts long values from this Observable via
+     * the provided function and computes the long sum of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an long from this Observable
+     * @return an Observable that extracts long values from this Observable via
+     * the provided function and computes the long sum of the value sequence.
+     */
+    public Observable sumLong(Func1 valueExtractor) {
+        return create(new OperationSum.SumLongExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts float values from this Observable via
+     * the provided function and computes the float sum of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an float from this Observable
+     * @return an Observable that extracts float values from this Observable via
+     * the provided function and computes the float sum of the value sequence.
+     */
+    public Observable sumFloat(Func1 valueExtractor) {
+        return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts double values from this Observable via
+     * the provided function and computes the double sum of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an double from this Observable
+     * @return an Observable that extracts double values from this Observable via
+     * the provided function and computes the double sum of the value sequence.
+     */
+    public Observable sumDouble(Func1 valueExtractor) {
+        return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
+    }
+    
     /**
      * Returns an Observable that computes the average of the Integers emitted
      * by the source Observable.
@@ -4183,6 +4232,54 @@ public static Observable averageDoubles(Observable source) {
         return OperationAverage.averageDoubles(source);
     }
 
+    /**
+     * Create an Observable that extracts integer values from this Observable via
+     * the provided function and computes the integer average of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an integer from this Observable
+     * @return an Observable that extracts integer values from this Observable via
+     * the provided function and computes the integer average of the value sequence.
+     */
+    public Observable averageInteger(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageIntegerExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts long values from this Observable via
+     * the provided function and computes the long average of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an long from this Observable
+     * @return an Observable that extracts long values from this Observable via
+     * the provided function and computes the long average of the value sequence.
+     */
+    public Observable averageLong(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageLongExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts float values from this Observable via
+     * the provided function and computes the float average of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an float from this Observable
+     * @return an Observable that extracts float values from this Observable via
+     * the provided function and computes the float average of the value sequence.
+     */
+    public Observable averageFloat(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageFloatExtractor(this, valueExtractor));
+    }
+
+    /**
+     * Create an Observable that extracts double values from this Observable via
+     * the provided function and computes the double average of the value sequence.
+     * 
+     * @param valueExtractor the function to extract an double from this Observable
+     * @return an Observable that extracts double values from this Observable via
+     * the provided function and computes the double average of the value sequence.
+     */
+    public Observable averageDouble(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageDoubleExtractor(this, valueExtractor));
+    }
+
     /**
      * Returns an Observable that emits the minimum item emitted by the source
      * Observable. If there is more than one such item, it returns the
@@ -4954,6 +5051,49 @@ public  Observable reduce(R initialValue, Func2 accumulat
     public  Observable aggregate(R initialValue, Func2 accumulator) {
         return reduce(initialValue, accumulator);
     }
+    
+    /**
+     * Create an Observable that aggregates the source values with the given accumulator
+     * function and projects the final result via the resultselector.
+     * 
    
+     * Works like the {@link #aggregate(java.lang.Object, rx.util.functions.Func2)} projected
+     * with {@link #map(rx.util.functions.Func1)} without the overhead of some helper
+     * operators.
+     * @param  the intermediate (accumulator) type
+     * @param  the result type
+     * @param seed the initial value of the accumulator
+     * @param accumulator the function that takes the current accumulator value,
+     *                    the current emitted value and returns a (new) accumulated value.
+     * @param resultSelector the selector to project the final value of the accumulator
+     * @return an Observable that aggregates the source values with the given accumulator
+     *         function and projects the final result via the resultselector
+     */
+    public  Observable aggregate(
+            U seed, Func2 accumulator, 
+            Func1 resultSelector) {
+        return create(new OperationAggregate.AggregateSelector(this, seed, accumulator, resultSelector));
+    }
+    
+    /**
+     * Create an Observable that aggregates the source values with the given indexed accumulator
+     * function and projects the final result via the indexed resultselector.
+     * 
+     * @param  the intermediate (accumulator) type
+     * @param  the result type
+     * @param seed the initial value of the accumulator
+     * @param accumulator the function that takes the current accumulator value,
+     *                    the current emitted value and returns a (new) accumulated value.
+     * @param resultSelector the selector to project the final value of the accumulator, where
+     *                       the second argument is the total number of elements accumulated
+     * @return an Observable that aggregates the source values with the given indexed accumulator
+     * function and projects the final result via the indexed resultselector.
+     */
+    public  Observable aggregateIndexed(
+            U seed, Func3 accumulator,
+        Func2 resultSelector
+    ) {
+        return create(new OperationAggregate.AggregateIndexedSelector(this, seed, accumulator, resultSelector));
+    }
 
     /**
      * Returns an Observable that applies a function of your choosing to the
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAggregate.java b/rxjava-core/src/main/java/rx/operators/OperationAggregate.java
new file mode 100644
index 0000000000..71778cccf1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperationAggregate.java
@@ -0,0 +1,158 @@
+/**
+ * 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 rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.util.functions.Func1;
+import rx.util.functions.Func2;
+import rx.util.functions.Func3;
+
+/**
+ * Aggregate overloads with index and selector functions.
+ */
+public final class OperationAggregate {
+    /** Utility class. */
+    private OperationAggregate() { throw new IllegalStateException("No instances!"); }
+    
+    /**
+     * Aggregate and emit a value after running it through a selector.
+     * @param  the input value type
+     * @param  the intermediate value type
+     * @param  the result value type
+     */
+    public static final class AggregateSelector implements OnSubscribeFunc {
+        final Observable source;
+        final U seed;
+        final Func2 aggregator;
+        final Func1 resultSelector;
+
+        public AggregateSelector(
+                Observable source, U seed, 
+                Func2 aggregator, 
+                Func1 resultSelector) {
+            this.source = source;
+            this.seed = seed;
+            this.aggregator = aggregator;
+            this.resultSelector = resultSelector;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AggregatorObserver(t1, seed));
+        }
+        /** The aggregator observer of the source. */
+        private final class AggregatorObserver implements Observer {
+            final Observer observer;
+            U accumulator;
+            public AggregatorObserver(Observer observer, U seed) {
+                this.observer = observer;
+                this.accumulator = seed;
+            }
+
+            @Override
+            public void onNext(T args) {
+                accumulator = aggregator.call(accumulator, args);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                accumulator = null;
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                U a = accumulator;
+                accumulator = null;
+                try {
+                    observer.onNext(resultSelector.call(a));
+                } catch (Throwable t) {
+                    observer.onError(t);
+                    return;
+                }
+                observer.onCompleted();
+            }
+        }
+    }
+    /**
+     * Indexed aggregate and emit a value after running it through an indexed selector.
+     * @param  the input value type
+     * @param  the intermediate value type
+     * @param  the result value type
+     */
+    public static final class AggregateIndexedSelector implements OnSubscribeFunc {
+        final Observable source;
+        final U seed;
+        final Func3 aggregator;
+        final Func2 resultSelector;
+
+        public AggregateIndexedSelector(
+                Observable source, 
+                U seed, 
+                Func3 aggregator, 
+                Func2 resultSelector) {
+            this.source = source;
+            this.seed = seed;
+            this.aggregator = aggregator;
+            this.resultSelector = resultSelector;
+        }
+
+        
+        
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AggregatorObserver(t1, seed));
+        }
+        /** The aggregator observer of the source. */
+        private final class AggregatorObserver implements Observer {
+            final Observer observer;
+            U accumulator;
+            int index;
+            public AggregatorObserver(Observer observer, U seed) {
+                this.observer = observer;
+                this.accumulator = seed;
+            }
+
+            @Override
+            public void onNext(T args) {
+                accumulator = aggregator.call(accumulator, args, index++);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                accumulator = null;
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                U a = accumulator;
+                accumulator = null;
+                try {
+                    observer.onNext(resultSelector.call(a, index));
+                } catch (Throwable t) {
+                    observer.onError(t);
+                    return;
+                }
+                observer.onCompleted();
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
index 35abc99eb5..29acf784d0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
@@ -16,6 +16,9 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
@@ -102,4 +105,228 @@ public Double call(Tuple2 result) {
             }
         });
     }
+    
+    /**
+     * Compute the average by extracting integer values from the source via an
+     * extractor function.
+     * @param  the source value type
+     */
+    public static final class AverageIntegerExtractor implements OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public AverageIntegerExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+        /** Computes the average. */
+        private final class AverageObserver implements Observer {
+            final Observer observer;
+            int sum;
+            int count;
+            public AverageObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+    
+    /**
+     * Compute the average by extracting long values from the source via an
+     * extractor function. 
+     * @param  the source value type
+     */
+    public static final class AverageLongExtractor implements OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public AverageLongExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+        /** Computes the average. */
+        private final class AverageObserver implements Observer {
+            final Observer observer;
+            long sum;
+            int count;
+            public AverageObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+    
+    /**
+     * Compute the average by extracting float values from the source via an
+     * extractor function. 
+     * @param  the source value type
+     */
+    public static final class AverageFloatExtractor implements OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public AverageFloatExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+        /** Computes the average. */
+        private final class AverageObserver implements Observer {
+            final Observer observer;
+            float sum;
+            int count;
+            public AverageObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+    
+    /**
+     * Compute the average by extracting double values from the source via an
+     * extractor function. 
+     * @param  the source value type
+     */
+    public static final class AverageDoubleExtractor implements OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public AverageDoubleExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+        /** Computes the average. */
+        private final class AverageObserver implements Observer {
+            final Observer observer;
+            double sum;
+            int count;
+            public AverageObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                count++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (count > 0) {
+                    try {
+                        observer.onNext(sum / count);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
index fef81a2625..8f419bd222 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSum.java
@@ -16,6 +16,10 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 /**
@@ -59,4 +63,229 @@ public Double call(Double accu, Double next) {
             }
         });
     }
+    
+    /**
+     * Compute the sum by extracting integer values from the source via an
+     * extractor function.
+     * @param  the source value type
+     */
+    public static final class SumIntegerExtractor implements Observable.OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public SumIntegerExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new SumObserver(t1));
+        }
+        /** Computes the average. */
+        private final class SumObserver implements Observer {
+            final Observer observer;
+            int sum;
+            boolean hasValue;
+            public SumObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                hasValue = true;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (hasValue) {
+                    try {
+                        observer.onNext(sum);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+    
+    /**
+     * Compute the sum by extracting long values from the source via an
+     * extractor function.
+     * @param  the source value type
+     */
+    public static final class SumLongExtractor implements Observable.OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public SumLongExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new SumObserver(t1));
+        }
+        /** Computes the average. */
+        private final class SumObserver implements Observer {
+            final Observer observer;
+            long sum;
+            boolean hasValue;
+            public SumObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                hasValue = true;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (hasValue) {
+                    try {
+                        observer.onNext(sum);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+    
+    /**
+     * Compute the sum by extracting float values from the source via an
+     * extractor function.
+     * @param  the source value type
+     */
+    public static final class SumFloatExtractor implements Observable.OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public SumFloatExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new SumObserver(t1));
+        }
+        /** Computes the average. */
+        private final class SumObserver implements Observer {
+            final Observer observer;
+            float sum;
+            boolean hasValue;
+            public SumObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                hasValue = true;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (hasValue) {
+                    try {
+                        observer.onNext(sum);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+
+    /**
+     * Compute the sum by extracting float values from the source via an
+     * extractor function.
+     * @param  the source value type
+     */
+    public static final class SumDoubleExtractor implements Observable.OnSubscribeFunc {
+        final Observable source;
+        final Func1 valueExtractor;
+
+        public SumDoubleExtractor(Observable source, Func1 valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new SumObserver(t1));
+        }
+        /** Computes the average. */
+        private final class SumObserver implements Observer {
+            final Observer observer;
+            double sum;
+            boolean hasValue;
+            public SumObserver(Observer observer) {
+                this.observer = observer;
+            }
+
+            @Override
+            public void onNext(T args) {
+                sum += valueExtractor.call(args);
+                hasValue = true;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (hasValue) {
+                    try {
+                        observer.onNext(sum);
+                    } catch (Throwable t) {
+                        observer.onError(t);
+                        return;
+                    }
+                    observer.onCompleted();
+                } else {
+                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
+                }
+            }
+            
+        }
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java b/rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java
new file mode 100644
index 0000000000..749af5b235
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java
@@ -0,0 +1,140 @@
+/**
+ * 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.Mock;
+import org.mockito.MockitoAnnotations;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.util.functions.Func1;
+import rx.util.functions.Func2;
+import rx.util.functions.Func3;
+import rx.util.functions.Functions;
+
+public class OperationAggregateTest {
+    @Mock
+    Observer observer;
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+    Func2 sum = new Func2() {
+        @Override
+        public Integer call(Integer t1, Integer t2) {
+            return t1 + t2;
+        }
+    };
+    
+    @Test
+    public void testAggregateAsIntSum() {
+        
+        Observable result = Observable.from(1, 2, 3, 4, 5).aggregate(0, sum, Functions.identity());
+        
+        result.subscribe(observer);
+        
+        verify(observer).onNext(1 + 2 + 3 + 4 + 5);
+        verify(observer).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+        
+    }
+    
+    @Test
+    public void testAggregateIndexedAsAverage() {
+        Func3 sumIndex = new Func3() {
+            @Override
+            public Integer call(Integer acc, Integer value, Integer index) {
+                return acc + (index + 1) + value;
+            }
+        };
+        Func2 selectIndex = new Func2() {
+            @Override
+            public Integer call(Integer t1, Integer count) {
+                return t1 + count;
+            }
+            
+        };
+        
+        Observable result = Observable.from(1, 2, 3, 4, 5)
+            .aggregateIndexed(0, sumIndex, selectIndex);
+        
+        result.subscribe(observer);
+        
+        verify(observer).onNext(2 + 4 + 6 + 8 + 10 + 5);
+        verify(observer).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+        
+    }
+    
+    static class CustomException extends RuntimeException { }
+    
+    @Test
+    public void testAggregateAsIntSumSourceThrows() {
+        Observable result = Observable.concat(Observable.from(1, 2, 3, 4, 5),
+            Observable.error(new CustomException()))
+            .aggregate(0, sum, Functions.identity());
+        
+        result.subscribe(observer);
+        
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(CustomException.class));
+    }
+    
+    @Test
+    public void testAggregateAsIntSumAccumulatorThrows() {
+        Func2 sumErr = new Func2() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = Observable.from(1, 2, 3, 4, 5)
+            .aggregate(0, sumErr, Functions.identity());
+        
+        result.subscribe(observer);
+        
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(CustomException.class));
+    }
+
+    @Test
+    public void testAggregateAsIntSumResultSelectorThrows() {
+        
+        Func1 error = new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = Observable.from(1, 2, 3, 4, 5)
+            .aggregate(0, sum, error);
+        
+        result.subscribe(observer);
+        
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(CustomException.class));
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
index 357743da17..8655c37437 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
@@ -15,7 +15,6 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationAverage.*;
 
@@ -23,6 +22,8 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.operators.OperationAggregateTest.CustomException;
+import rx.util.functions.Func1;
 
 public class OperationAverageTest {
 
@@ -118,4 +119,207 @@ public void testEmptyAverageDoubles() throws Throwable {
         verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
         verify(wd, never()).onCompleted();
     }
+    
+    void testThrows(Observer o, Class errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+     void testValue(Observer o, N value) {
+        verify(o, times(1)).onNext(value);
+        verify(o, times(1)).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testIntegerAverageSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+        
+        Observable result = source.averageInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 2);
+    }
+    @Test
+    public void testLongAverageSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                return (long)t1.length();
+            }
+        };
+        
+        Observable result = source.averageLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 2L);
+    }
+    @Test
+    public void testFloatAverageSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                return (float)t1.length();
+            }
+        };
+        
+        Observable result = source.averageFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 2.5f);
+    }
+    @Test
+    public void testDoubleAverageSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                return (double)t1.length();
+            }
+        };
+        
+        Observable result = source.averageDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 2.5d);
+    }
+    @Test
+    public void testIntegerAverageSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+        
+        Observable result = source.averageInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testLongAverageSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                return (long)t1.length();
+            }
+        };
+        
+        Observable result = source.averageLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testFloatAverageSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                return (float)t1.length();
+            }
+        };
+        
+        Observable result = source.averageFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testDoubleAverageSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                return (double)t1.length();
+            }
+        };
+        
+        Observable result = source.averageDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testIntegerAverageSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = source.averageInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, CustomException.class);
+    }
+    @Test
+    public void testLongAverageSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = source.averageLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, CustomException.class);
+    }
+    @Test
+    public void testFloatAverageSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = source.averageFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, CustomException.class);
+    }
+    @Test
+    public void testDoubleAverageSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = source.averageDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, CustomException.class);
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index e124ad13d5..2fcc4611e1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -23,6 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.util.functions.Func1;
 
 public class OperationSumTest {
 
@@ -122,4 +123,208 @@ public void testEmptySumDoubles() throws Throwable {
         verify(wd, never()).onError(any(Throwable.class));
         verify(wd, times(1)).onCompleted();
     }
+    
+    void testThrows(Observer o, Class errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+     void testValue(Observer o, N value) {
+        verify(o, times(1)).onNext(value);
+        verify(o, times(1)).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testIntegerSumSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+        
+        Observable result = source.sumInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 10);
+    }
+    @Test
+    public void testLongSumSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                return (long)t1.length();
+            }
+        };
+        
+        Observable result = source.sumLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 10L);
+    }
+    @Test
+    public void testFloatSumSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                return (float)t1.length();
+            }
+        };
+        
+        Observable result = source.sumFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 10f);
+    }
+    @Test
+    public void testDoubleSumSelector() {
+        Observable source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                return (double)t1.length();
+            }
+        };
+        
+        Observable result = source.sumDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testValue(o, 10d);
+    }
+    @Test
+    public void testIntegerSumSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+        
+        Observable result = source.sumInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testLongSumSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                return (long)t1.length();
+            }
+        };
+        
+        Observable result = source.sumLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testFloatSumSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                return (float)t1.length();
+            }
+        };
+        
+        Observable result = source.sumFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testDoubleSumSelectorEmpty() {
+        Observable source = Observable.empty();
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                return (double)t1.length();
+            }
+        };
+        
+        Observable result = source.sumDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, IllegalArgumentException.class);
+    }
+    @Test
+    public void testIntegerSumSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Integer call(String t1) {
+                throw new OperationAggregateTest.CustomException();
+            }
+        };
+        
+        Observable result = source.sumInteger(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, OperationAggregateTest.CustomException.class);
+    }
+    @Test
+    public void testLongSumSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Long call(String t1) {
+                throw new OperationAggregateTest.CustomException();
+            }
+        };
+        
+        Observable result = source.sumLong(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, OperationAggregateTest.CustomException.class);
+    }
+    @Test
+    public void testFloatSumSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Float call(String t1) {
+                throw new OperationAggregateTest.CustomException();
+            }
+        };
+        
+        Observable result = source.sumFloat(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, OperationAggregateTest.CustomException.class);
+    }
+    @Test
+    public void testDoubleSumSelectorThrows() {
+        Observable source = Observable.from("a");
+        Func1 length = new Func1() {
+            @Override
+            public Double call(String t1) {
+                throw new OperationAggregateTest.CustomException();
+            }
+        };
+        
+        Observable result = source.sumDouble(length);
+        Observer o = mock(Observer.class);
+        result.subscribe(o);
+        
+        testThrows(o, OperationAggregateTest.CustomException.class);
+    }
 }

From 392238fa73b05243c6cd6218000ab1b9dd6e504c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 10:24:50 -0800
Subject: [PATCH 116/441] Comments on Performance Increase

---
 .../test/java/rx/subjects/SubjectPerformanceTests.java    | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java b/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java
index 2574b1bcd9..4edcaabe81 100644
--- a/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java
+++ b/rxjava-core/src/test/java/rx/subjects/SubjectPerformanceTests.java
@@ -115,6 +115,14 @@ public long baseline() {
      * Run: 12 - 16,158,874 ops/sec
      * Run: 13 - 16,209,504 ops/sec
      * Run: 14 - 16,151,174 ops/sec
+     * 
+     * Map to Arrays and other enhancements from https://github.com/Netflix/RxJava/pull/652
+     * 
+     * Run: 10 - 54,231,405 ops/sec
+     * Run: 11 - 56,239,490 ops/sec
+     * Run: 12 - 55,424,384 ops/sec
+     * Run: 13 - 56,370,421 ops/sec
+     * Run: 14 - 56,617,767 ops/sec
      */
     public long unboundedReplaySubject() {
         ReplaySubject s = ReplaySubject.create();

From 4af68d8eda2c4a40fcb0aa4eae49f18254ecf8af Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 10:34:58 -0800
Subject: [PATCH 117/441] Reverting to Previous SafeObserver

- Performance difference between changes are trivial at best so preferring to keep code that is easier to understand.

Test numbers:

```
Old SafeObserver

Run: 0 - 3,751,704 ops/sec
Run: 1 - 34,619,086 ops/sec
Run: 2 - 30,483,715 ops/sec
Run: 3 - 27,746,023 ops/sec
Run: 4 - 54,078,608 ops/sec
Run: 5 - 55,107,045 ops/sec
Run: 6 - 53,935,396 ops/sec
Run: 7 - 54,947,168 ops/sec
Run: 8 - 57,024,246 ops/sec
Run: 9 - 55,059,712 ops/sec
Run: 10 - 56,904,832 ops/sec
Run: 11 - 55,919,967 ops/sec
Run: 12 - 55,076,087 ops/sec
Run: 13 - 55,066,685 ops/sec
Run: 14 - 55,025,476 ops/sec

Run: 0 - 3,839,266 ops/sec
Run: 1 - 34,115,371 ops/sec
Run: 2 - 29,675,175 ops/sec
Run: 3 - 28,677,042 ops/sec
Run: 4 - 55,405,652 ops/sec
Run: 5 - 55,260,220 ops/sec
Run: 6 - 55,147,464 ops/sec
Run: 7 - 54,261,126 ops/sec
Run: 8 - 53,941,505 ops/sec
Run: 9 - 54,324,501 ops/sec
Run: 10 - 55,125,576 ops/sec
Run: 11 - 56,102,870 ops/sec
Run: 12 - 55,061,834 ops/sec
Run: 13 - 55,476,039 ops/sec
Run: 14 - 55,073,054 ops/sec

Run: 0 - 3,704,536 ops/sec
Run: 1 - 34,694,514 ops/sec
Run: 2 - 30,778,227 ops/sec
Run: 3 - 28,441,329 ops/sec
Run: 4 - 54,116,946 ops/sec
Run: 5 - 55,204,699 ops/sec
Run: 6 - 54,859,450 ops/sec
Run: 7 - 55,214,757 ops/sec
Run: 8 - 55,005,500 ops/sec
Run: 9 - 55,339,118 ops/sec
Run: 10 - 55,501,903 ops/sec
Run: 11 - 55,074,570 ops/sec
Run: 12 - 55,102,187 ops/sec
Run: 13 - 55,756,278 ops/sec
Run: 14 - 54,768,411 ops/sec

New SafeObserver

Run: 0 - 3,983,308 ops/sec
Run: 1 - 34,767,250 ops/sec
Run: 2 - 30,806,957 ops/sec
Run: 3 - 29,855,113 ops/sec
Run: 4 - 57,451,453 ops/sec
Run: 5 - 55,515,152 ops/sec
Run: 6 - 56,086,822 ops/sec
Run: 7 - 56,295,529 ops/sec
Run: 8 - 55,371,905 ops/sec
Run: 9 - 55,816,653 ops/sec
Run: 10 - 55,793,296 ops/sec
Run: 11 - 56,011,426 ops/sec
Run: 12 - 55,568,521 ops/sec
Run: 13 - 55,396,137 ops/sec
Run: 14 - 56,353,267 ops/sec

Run: 0 - 3,933,367 ops/sec
Run: 1 - 34,498,342 ops/sec
Run: 2 - 30,233,584 ops/sec
Run: 3 - 29,179,785 ops/sec
Run: 4 - 55,761,874 ops/sec
Run: 5 - 55,948,124 ops/sec
Run: 6 - 55,264,801 ops/sec
Run: 7 - 56,267,020 ops/sec
Run: 8 - 57,474,567 ops/sec
Run: 9 - 55,879,657 ops/sec
Run: 10 - 55,998,880 ops/sec
Run: 11 - 56,044,073 ops/sec
Run: 12 - 55,498,515 ops/sec
Run: 13 - 56,204,720 ops/sec
Run: 14 - 55,845,954 ops/sec

Run: 0 - 3,981,914 ops/sec
Run: 1 - 34,160,822 ops/sec
Run: 2 - 30,873,631 ops/sec
Run: 3 - 29,135,067 ops/sec
Run: 4 - 55,845,330 ops/sec
Run: 5 - 55,101,883 ops/sec
Run: 6 - 55,724,276 ops/sec
Run: 7 - 56,085,564 ops/sec
Run: 8 - 55,639,942 ops/sec
Run: 9 - 56,464,955 ops/sec
Run: 10 - 55,453,275 ops/sec
Run: 11 - 56,115,463 ops/sec
Run: 12 - 56,509,945 ops/sec
Run: 13 - 53,863,348 ops/sec
Run: 14 - 55,866,858 ops/sec
```
---
 .../main/java/rx/operators/SafeObserver.java  | 34 +++++--------------
 1 file changed, 8 insertions(+), 26 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 7f32114dbc..3e6508dac9 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -57,25 +57,10 @@
  */
 public class SafeObserver implements Observer {
 
-    private volatile Observer actual;
+    private final Observer actual;
     private final AtomicBoolean isFinished = new AtomicBoolean(false);
     private final SafeObservableSubscription subscription;
-    /** 
-     * If the observer completes, this is swapped in place of the actual
-     * should avoid the overhead of isFinished.get() on every onNext call. */
-    private static final Observer nopObserver = new Observer() {
-        @Override
-        public void onNext(Object args) {
-        }
-        @Override
-        public void onError(Throwable e) {
-        }
 
-        @Override
-        public void onCompleted() {
-        }
-        
-    };
     public SafeObserver(SafeObservableSubscription subscription, Observer actual) {
         this.subscription = subscription;
         this.actual = actual;
@@ -84,10 +69,8 @@ public SafeObserver(SafeObservableSubscription subscription, Observer
     @Override
     public void onCompleted() {
         if (isFinished.compareAndSet(false, true)) {
-            Observer a = actual;
-            actual = nopObserver;
             try {
-                a.onCompleted();
+                actual.onCompleted();
             } catch (Throwable e) {
                 // handle errors if the onCompleted implementation fails, not just if the Observable fails
                 onError(e);
@@ -100,11 +83,8 @@ public void onCompleted() {
     @Override
     public void onError(Throwable e) {
         if (isFinished.compareAndSet(false, true)) {
-            Observer a = actual;
-            // will prevent onNext from sending a new value after completion
-            actual = nopObserver;
             try {
-                a.onError(e);
+                actual.onError(e);
             } catch (Throwable e2) {
                 if (e2 instanceof OnErrorNotImplementedException) {
                     /**
@@ -137,10 +117,12 @@ public void onError(Throwable e) {
     @Override
     public void onNext(T args) {
         try {
-            actual.onNext(args);
-        } catch (Throwable t) {
+            if (!isFinished.get()) {
+                actual.onNext(args);
+            }
+        } catch (Throwable e) {
             // handle errors if the onNext implementation fails, not just if the Observable fails
-            onError(t);
+            onError(e);
         }
     }
 

From cbd9a3caa39e4829c393b851f41894552db0610d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 11:16:42 -0800
Subject: [PATCH 118/441] BooleanSubscription: Add Action Support

---
 .../rx/subscriptions/BooleanSubscription.java | 26 +++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
index 7b18b35efc..31c904e47f 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
@@ -19,6 +19,7 @@
 
 import rx.Observable;
 import rx.Subscription;
+import rx.util.functions.Action0;
 
 /**
  * Subscription that can be checked for status such as in a loop inside an {@link Observable} to exit the loop if unsubscribed.
@@ -28,14 +29,35 @@
 public class BooleanSubscription implements Subscription {
 
     private final AtomicBoolean unsubscribed = new AtomicBoolean(false);
+    private final Action0 action;
+
+    public BooleanSubscription() {
+        action = null;
+    }
+
+    private BooleanSubscription(Action0 action) {
+        this.action = action;
+    }
+
+    public static BooleanSubscription create() {
+        return new BooleanSubscription();
+    }
+
+    public static BooleanSubscription create(Action0 onUnsubscribe) {
+        return new BooleanSubscription(onUnsubscribe);
+    }
 
     public boolean isUnsubscribed() {
         return unsubscribed.get();
     }
 
     @Override
-    public void unsubscribe() {
-        unsubscribed.set(true);
+    public final void unsubscribe() {
+        if (unsubscribed.compareAndSet(false, true)) {
+            if (action != null) {
+                action.call();
+            }
+        }
     }
 
 }

From 6383157b2961749ab46b8d05653ffb5f757f0be8 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 11:17:09 -0800
Subject: [PATCH 119/441] Remove Unnecessary Subscription

- be explicit for error case in JoinObserver
---
 .../src/main/java/rx/joins/JoinObserver1.java | 17 ++--
 .../SingleAssignmentSubscription.java         | 81 -------------------
 2 files changed, 12 insertions(+), 86 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java

diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index 873d3d1a7f..ede55f0584 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -19,9 +19,11 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import rx.Notification;
 import rx.Observable;
-import rx.subscriptions.SingleAssignmentSubscription;
+import rx.operators.SafeObservableSubscription;
 import rx.util.functions.Action1;
 
 /**
@@ -33,14 +35,15 @@ public final class JoinObserver1 extends ObserverBase> implem
     private final Action1 onError;
     private final List activePlans;
     private final Queue> queue;
-    private final SingleAssignmentSubscription subscription;
+    private final SafeObservableSubscription subscription;
     private volatile boolean done;
+    private final AtomicBoolean subscribed = new AtomicBoolean(false);
     
     public JoinObserver1(Observable source, Action1 onError) {
         this.source = source;
         this.onError = onError;
         queue = new LinkedList>();
-        subscription = new SingleAssignmentSubscription();
+        subscription = new SafeObservableSubscription();
         activePlans = new ArrayList();
     }
     public Queue> queue() {
@@ -51,8 +54,12 @@ public void addActivePlan(ActivePlan0 activePlan) {
     }
     @Override
     public void subscribe(Object gate) {
-        this.gate = gate;
-        subscription.set(source.materialize().subscribe(this));
+        if (subscribed.compareAndSet(false, true)) {
+            this.gate = gate;
+            subscription.wrap(source.materialize().subscribe(this));
+        } else {
+            throw new IllegalStateException("Can only be subscribed to once.");
+        }
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java
deleted file mode 100644
index c960db2ea4..0000000000
--- a/rxjava-core/src/main/java/rx/subscriptions/SingleAssignmentSubscription.java
+++ /dev/null
@@ -1,81 +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.subscriptions;
-
-import java.util.concurrent.atomic.AtomicReference;
-import rx.Subscription;
-
-/**
- * A subscription that allows only a single resource to be assigned.
- * 
    
- * If this subscription is live, no other subscription may be set() and
- * yields an {@link IllegalStateException}.
- * 
    
- * If the unsubscribe has been called, setting a new subscription will
- * unsubscribe it immediately.
- */
-public final class SingleAssignmentSubscription implements Subscription {
-    /** Holds the current resource. */
-    private final AtomicReference current = new AtomicReference();
-    /** Sentinel for the unsubscribed state. */
-    private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() {
-        @Override
-        public void unsubscribe() {
-        }
-    };
-    /**
-     * Returns the current subscription or null if not yet set.
-     */
-    public Subscription get() {
-        Subscription s = current.get();
-        if (s == UNSUBSCRIBED_SENTINEL) {
-            return Subscriptions.empty();
-        }
-        return s;
-    }
-    /**
-     * Sets a new subscription if not already set.
-     * @param s the new subscription
-     * @throws IllegalStateException if this subscription is live and contains
-     * another subscription.
-     */
-    public void set(Subscription s) {
-        if (current.compareAndSet(null, s)) {
-            return;
-        }
-        if (current.get() != UNSUBSCRIBED_SENTINEL) {
-            throw new IllegalStateException("Subscription already set");
-        }
-        if (s != null) {
-            s.unsubscribe();
-        }
-    }
-    @Override
-    public void unsubscribe() {
-        Subscription old = current.getAndSet(UNSUBSCRIBED_SENTINEL);
-        if (old != null) {
-            old.unsubscribe();
-        }
-    }
-    /**
-     * Test if this subscription is already unsubscribed.
-     */
-    public boolean isUnsubscribed() {
-        return current.get() == UNSUBSCRIBED_SENTINEL;
-    }
-    
-}

From dccbc6baa53c9c8714d70067cb5c97fed023e472 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 11:17:20 -0800
Subject: [PATCH 120/441] Code Reformatting

---
 .../subscriptions/CompositeSubscription.java  | 76 ++++++++++---------
 .../MultipleAssignmentSubscription.java       | 10 +--
 .../subscriptions/RefCountSubscription.java   | 16 +++-
 .../rx/subscriptions/SerialSubscription.java  |  4 +-
 4 files changed, 60 insertions(+), 46 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index c19331c8ec..ee715df7f7 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -1,18 +1,18 @@
- /**
-  * 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.
-  */
+/**
+ * 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.subscriptions;
 
 import static java.util.Arrays.asList;
@@ -31,27 +31,25 @@
 /**
  * Subscription that represents a group of Subscriptions that are unsubscribed
  * together.
- *
- * @see Rx.Net
- *      equivalent CompositeDisposable
+ * 
+ * @see Rx.Net equivalent CompositeDisposable
  */
 public class CompositeSubscription implements Subscription {
     /** Sentinel to indicate a thread is modifying the subscription set. */
-    private static final Set MUTATE_SENTINEL = unmodifiableSet(Collections.emptySet());
-    /** Sentinel to indicate the entire CompositeSubscription has been unsubscribed.*/
-    private static final Set UNSUBSCRIBED_SENTINEL = unmodifiableSet(Collections.emptySet());
+    private static final Set MUTATE_SENTINEL = unmodifiableSet(Collections. emptySet());
+    /** Sentinel to indicate the entire CompositeSubscription has been unsubscribed. */
+    private static final Set UNSUBSCRIBED_SENTINEL = unmodifiableSet(Collections. emptySet());
     /** The reference to the set of subscriptions. */
     private final AtomicReference> reference = new AtomicReference>();
-    
+
     public CompositeSubscription(final Subscription... subscriptions) {
         reference.set(new HashSet(asList(subscriptions)));
     }
-    
+
     public boolean isUnsubscribed() {
         return reference.get() == UNSUBSCRIBED_SENTINEL;
     }
-    
+
     public void add(final Subscription s) {
         do {
             final Set existing = reference.get();
@@ -59,11 +57,11 @@ public void add(final Subscription s) {
                 s.unsubscribe();
                 break;
             }
-            
+
             if (existing == MUTATE_SENTINEL) {
                 continue;
             }
-            
+
             if (reference.compareAndSet(existing, MUTATE_SENTINEL)) {
                 existing.add(s);
                 reference.set(existing);
@@ -71,7 +69,7 @@ public void add(final Subscription s) {
             }
         } while (true);
     }
-    
+
     public void remove(final Subscription s) {
         do {
             final Set subscriptions = reference.get();
@@ -79,11 +77,11 @@ public void remove(final Subscription s) {
                 s.unsubscribe();
                 break;
             }
-            
+
             if (subscriptions == MUTATE_SENTINEL) {
                 continue;
             }
-            
+
             if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) {
                 // also unsubscribe from it:
                 // http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable.remove(v=vs.103).aspx
@@ -94,36 +92,39 @@ public void remove(final Subscription s) {
             }
         } while (true);
     }
-    
+
     public void clear() {
         do {
             final Set subscriptions = reference.get();
             if (subscriptions == UNSUBSCRIBED_SENTINEL) {
                 break;
             }
-            
+
             if (subscriptions == MUTATE_SENTINEL) {
                 continue;
             }
-            
+
             if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) {
                 final Set copy = new HashSet(
                         subscriptions);
                 subscriptions.clear();
                 reference.set(subscriptions);
-                
+
                 unsubscribeAll(copy);
                 break;
             }
         } while (true);
     }
+
     /**
      * Unsubscribe from the collection of subscriptions.
      * 
    
      * Exceptions thrown by any of the {@code unsubscribe()} methods are
      * collected into a {@link CompositeException} and thrown once
      * all unsubscriptions have been attempted.
-     * @param subs the collection of subscriptions
+     * 
+     * @param subs
+     *            the collection of subscriptions
      */
     private void unsubscribeAll(Collection subs) {
         final Collection es = new ArrayList();
@@ -139,6 +140,7 @@ private void unsubscribeAll(Collection subs) {
                     "Failed to unsubscribe to 1 or more subscriptions.", es);
         }
     }
+
     @Override
     public void unsubscribe() {
         do {
@@ -146,11 +148,11 @@ public void unsubscribe() {
             if (subscriptions == UNSUBSCRIBED_SENTINEL) {
                 break;
             }
-            
+
             if (subscriptions == MUTATE_SENTINEL) {
                 continue;
             }
-            
+
             if (reference.compareAndSet(subscriptions, UNSUBSCRIBED_SENTINEL)) {
                 unsubscribeAll(subscriptions);
                 break;
diff --git a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index 8fed35fbbf..9f734dcccf 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,7 +15,6 @@
  */
 package rx.subscriptions;
 
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
@@ -34,6 +33,7 @@ public class MultipleAssignmentSubscription implements Subscription {
         public void unsubscribe() {
         }
     };
+
     public boolean isUnsubscribed() {
         return reference.get() == UNSUBSCRIBED_SENTINEL;
     }
diff --git a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
index a4747caa9b..18aa16cc43 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -33,6 +33,7 @@ private enum State {
         MUTATING,
         UNSUBSCRIBED
     }
+
     /** The reference to the actual subscription. */
     private volatile Subscription main;
     /** The current state. */
@@ -41,9 +42,11 @@ private enum State {
     private final AtomicInteger count = new AtomicInteger();
     /** Indicate the request to unsubscribe from the main. */
     private final AtomicBoolean mainDone = new AtomicBoolean();
+
     /**
      * Create a RefCountSubscription by wrapping the given non-null Subscription.
-     * @param s 
+     * 
+     * @param s
      */
     public RefCountSubscription(Subscription s) {
         if (s == null) {
@@ -51,6 +54,7 @@ public RefCountSubscription(Subscription s) {
         }
         this.main = s;
     }
+
     /**
      * Returns a new sub-subscription.
      */
@@ -68,14 +72,16 @@ public Subscription getSubscription() {
                 state.set(State.ACTIVE);
                 return new InnerSubscription();
             }
-        } while(true);
+        } while (true);
     }
+
     /**
      * Check if this subscription is already unsubscribed.
      */
     public boolean isUnsubscribed() {
         return state.get() == State.UNSUBSCRIBED;
     }
+
     @Override
     public void unsubscribe() {
         do {
@@ -96,7 +102,8 @@ public void unsubscribe() {
             }
         } while (true);
     }
-    /** 
+
+    /**
      * Terminate this subscription by unsubscribing from main and setting the
      * state to UNSUBSCRIBED.
      */
@@ -106,6 +113,7 @@ private void terminate() {
         main = null;
         r.unsubscribe();
     }
+
     /** Remove an inner subscription. */
     void innerDone() {
         do {
@@ -126,9 +134,11 @@ void innerDone() {
             }
         } while (true);
     }
+
     /** The individual sub-subscriptions. */
     class InnerSubscription implements Subscription {
         final AtomicBoolean innerDone = new AtomicBoolean();
+
         @Override
         public void unsubscribe() {
             if (innerDone.compareAndSet(false, true)) {
diff --git a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
index e26a258acc..a0d8478130 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -35,9 +35,11 @@ public class SerialSubscription implements Subscription {
         public void unsubscribe() {
         }
     };
+
     public boolean isUnsubscribed() {
         return reference.get() == UNSUBSCRIBED_SENTINEL;
     }
+
     @Override
     public void unsubscribe() {
         Subscription s = reference.getAndSet(UNSUBSCRIBED_SENTINEL);
@@ -59,7 +61,7 @@ public void setSubscription(final Subscription subscription) {
             }
         } while (true);
     }
-    
+
     public Subscription getSubscription() {
         final Subscription subscription = reference.get();
         return subscription == UNSUBSCRIBED_SENTINEL ? Subscriptions.empty() : subscription;

From c45fce2b0daa1921863c9acaafa3f36d34f4b4a0 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Mon, 23 Dec 2013 20:43:57 +0100
Subject: [PATCH 121/441] Missing fixes from the subject rewrite.

---
 .../java/rx/subjects/BehaviorSubject.java     | 13 ++---
 .../subjects/SubjectSubscriptionManager.java  |  1 +
 .../java/rx/subjects/BehaviorSubjectTest.java | 50 +++++++++++++++++++
 3 files changed, 58 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 4af0c54b2c..21f6252295 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -169,12 +169,13 @@ public void call(Collection> observers) {
 
     @Override
     public void onNext(T v) {
-        /**
-         * Store the latest value but do not send it. It only gets sent when 'onCompleted' occurs.
-         */
-        lastNotification.set(new Notification(v));
-        for (Observer o : subscriptionManager.rawSnapshot()) {
-            o.onNext(v);
+        // do not overwrite a terminal notification
+        // so new subscribers can get them
+        if (lastNotification.get().isOnNext()) {
+            lastNotification.set(new Notification(v));
+            for (Observer o : subscriptionManager.rawSnapshot()) {
+                o.onNext(v);
+            }
         }
     }
 
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index ff7033c0c5..dfe6062a57 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -65,6 +65,7 @@ public Subscription onSubscribe(Observer actualObserver) {
                         try {
                             current.terminationLatch.await();
                         } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
                             throw new RuntimeException("Interrupted waiting for termination.", e);
                         }
                         break;
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 19badb2d95..caca18204d 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -185,5 +185,55 @@ public void testCompletedAfterErrorIsNotSent() {
         verify(aObserver, never()).onNext("two");
         verify(aObserver, never()).onCompleted();
     }
+    @Test
+    public void testCompletedAfterErrorIsNotSent2() {
+        BehaviorSubject subject = BehaviorSubject.create("default");
+
+        @SuppressWarnings("unchecked")
+        Observer aObserver = mock(Observer.class);
+        subject.subscribe(aObserver);
+
+        subject.onNext("one");
+        subject.onError(testException);
+        subject.onNext("two");
+        subject.onCompleted();
+
+        verify(aObserver, times(1)).onNext("default");
+        verify(aObserver, times(1)).onNext("one");
+        verify(aObserver, times(1)).onError(testException);
+        verify(aObserver, never()).onNext("two");
+        verify(aObserver, never()).onCompleted();
+
+        Observer o2 = mock(Observer.class);
+        subject.subscribe(o2);
+        verify(o2, times(1)).onError(testException);
+        verify(o2, never()).onNext(any());
+        verify(o2, never()).onCompleted();
+    }
+    
+    @Test
+    public void testCompletedAfterErrorIsNotSent3() {
+        BehaviorSubject subject = BehaviorSubject.create("default");
+
+        @SuppressWarnings("unchecked")
+        Observer aObserver = mock(Observer.class);
+        subject.subscribe(aObserver);
+
+        subject.onNext("one");
+        subject.onCompleted();
+        subject.onNext("two");
+        subject.onCompleted();
 
+        verify(aObserver, times(1)).onNext("default");
+        verify(aObserver, times(1)).onNext("one");
+        verify(aObserver, times(1)).onCompleted();
+        verify(aObserver, never()).onError(any(Throwable.class));
+        verify(aObserver, never()).onNext("two");
+
+        Observer o2 = mock(Observer.class);
+        subject.subscribe(o2);
+        verify(o2, times(1)).onCompleted();
+        verify(o2, never()).onNext(any());
+        verify(aObserver, never()).onError(any(Throwable.class));
+    }
 }

From 109572d78b41a1f872b9688a76b174841e6a6750 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 11:41:42 -0800
Subject: [PATCH 122/441] Refactor RefCountSubscription

- simplified logic
- remove unnecessary busy spins and state changes
---
 .../subscriptions/RefCountSubscription.java   | 129 ++++++++----------
 1 file changed, 56 insertions(+), 73 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
index 18aa16cc43..091b9dcb1e 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -16,8 +16,8 @@
 package rx.subscriptions;
 
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Subscription;
 
 /**
@@ -27,21 +27,33 @@
  * @see MSDN RefCountDisposable
  */
 public class RefCountSubscription implements Subscription {
-    /** The state for the atomic operations. */
-    private enum State {
-        ACTIVE,
-        MUTATING,
-        UNSUBSCRIBED
-    }
-
     /** The reference to the actual subscription. */
-    private volatile Subscription main;
-    /** The current state. */
-    private final AtomicReference state = new AtomicReference();
-    /** Counts the number of sub-subscriptions. */
-    private final AtomicInteger count = new AtomicInteger();
-    /** Indicate the request to unsubscribe from the main. */
-    private final AtomicBoolean mainDone = new AtomicBoolean();
+    private final Subscription actual;
+    /** Counts the number of subscriptions (1 parent + multiple children) */
+    private final AtomicReference state = new AtomicReference(new State(false, 0));
+
+    private static final class State {
+        final boolean isUnsubscribed;
+        final int children;
+
+        State(boolean u, int c) {
+            this.isUnsubscribed = u;
+            this.children = c;
+        }
+
+        State addChild() {
+            return new State(isUnsubscribed, children + 1);
+        }
+
+        State removeChild() {
+            return new State(isUnsubscribed, children - 1);
+        }
+
+        State unsubscribe() {
+            return new State(true, children);
+        }
+
+    }
 
     /**
      * Create a RefCountSubscription by wrapping the given non-null Subscription.
@@ -52,87 +64,52 @@ public RefCountSubscription(Subscription s) {
         if (s == null) {
             throw new IllegalArgumentException("s");
         }
-        this.main = s;
+        this.actual = s;
     }
 
     /**
      * Returns a new sub-subscription.
      */
     public Subscription getSubscription() {
+        State current;
+        State newState;
         do {
-            State s = state.get();
-            if (s == State.UNSUBSCRIBED) {
+            current = state.get();
+            if (current.isUnsubscribed) {
                 return Subscriptions.empty();
+            } else {
+                newState = current.addChild();
             }
-            if (s == State.MUTATING) {
-                continue;
-            }
-            if (state.compareAndSet(s, State.MUTATING)) {
-                count.incrementAndGet();
-                state.set(State.ACTIVE);
-                return new InnerSubscription();
-            }
-        } while (true);
+        } while (!state.compareAndSet(current, newState));
+
+        return new InnerSubscription();
     }
 
     /**
      * Check if this subscription is already unsubscribed.
      */
     public boolean isUnsubscribed() {
-        return state.get() == State.UNSUBSCRIBED;
+        return state.get().isUnsubscribed;
     }
 
     @Override
     public void unsubscribe() {
+        State current;
+        State newState;
         do {
-            State s = state.get();
-            if (s == State.UNSUBSCRIBED) {
+            current = state.get();
+            if (current.isUnsubscribed) {
                 return;
             }
-            if (s == State.MUTATING) {
-                continue;
-            }
-            if (state.compareAndSet(s, State.MUTATING)) {
-                if (mainDone.compareAndSet(false, true) && count.get() == 0) {
-                    terminate();
-                    return;
-                }
-                state.set(State.ACTIVE);
-                break;
-            }
-        } while (true);
-    }
-
-    /**
-     * Terminate this subscription by unsubscribing from main and setting the
-     * state to UNSUBSCRIBED.
-     */
-    private void terminate() {
-        state.set(State.UNSUBSCRIBED);
-        Subscription r = main;
-        main = null;
-        r.unsubscribe();
+            newState = current.unsubscribe();
+        } while (!state.compareAndSet(current, newState));
+        unsubscribeActualIfApplicable(newState);
     }
 
-    /** Remove an inner subscription. */
-    void innerDone() {
-        do {
-            State s = state.get();
-            if (s == State.UNSUBSCRIBED) {
-                return;
-            }
-            if (s == State.MUTATING) {
-                continue;
-            }
-            if (state.compareAndSet(s, State.MUTATING)) {
-                if (count.decrementAndGet() == 0 && mainDone.get()) {
-                    terminate();
-                    return;
-                }
-                state.set(State.ACTIVE);
-                break;
-            }
-        } while (true);
+    private void unsubscribeActualIfApplicable(State state) {
+        if (state.isUnsubscribed && state.children == 0) {
+            actual.unsubscribe();
+        }
     }
 
     /** The individual sub-subscriptions. */
@@ -142,7 +119,13 @@ class InnerSubscription implements Subscription {
         @Override
         public void unsubscribe() {
             if (innerDone.compareAndSet(false, true)) {
-                innerDone();
+                State current;
+                State newState;
+                do {
+                    current = state.get();
+                    newState = current.removeChild();
+                } while (!state.compareAndSet(current, newState));
+                unsubscribeActualIfApplicable(newState);
             }
         }
     };

From c3ee3483ad038151fdcacbcf0c69ca079f47ba7b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 12:03:39 -0800
Subject: [PATCH 123/441] Refactor CompositeSubscription

- simplified state machine
- removed busy spin state
---
 .../subscriptions/CompositeSubscription.java  | 178 +++++++++---------
 1 file changed, 84 insertions(+), 94 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index ee715df7f7..2b298c35b2 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -15,14 +15,10 @@
  */
 package rx.subscriptions;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.unmodifiableSet;
-
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Subscription;
@@ -35,103 +31,116 @@
  * @see Rx.Net equivalent CompositeDisposable
  */
 public class CompositeSubscription implements Subscription {
-    /** Sentinel to indicate a thread is modifying the subscription set. */
-    private static final Set MUTATE_SENTINEL = unmodifiableSet(Collections. emptySet());
-    /** Sentinel to indicate the entire CompositeSubscription has been unsubscribed. */
-    private static final Set UNSUBSCRIBED_SENTINEL = unmodifiableSet(Collections. emptySet());
-    /** The reference to the set of subscriptions. */
-    private final AtomicReference> reference = new AtomicReference>();
+
+    private final AtomicReference state = new AtomicReference();
+
+    private static final class State {
+        final boolean isUnsubscribed;
+        final List subscriptions;
+
+        State(boolean u, List s) {
+            this.isUnsubscribed = u;
+            this.subscriptions = s;
+        }
+
+        State unsubscribe() {
+            return new State(true, subscriptions);
+        }
+
+        State add(Subscription s) {
+            List newSubscriptions = new ArrayList();
+            newSubscriptions.addAll(subscriptions);
+            newSubscriptions.add(s);
+            return new State(isUnsubscribed, newSubscriptions);
+        }
+
+        State remove(Subscription s) {
+            List newSubscriptions = new ArrayList();
+            newSubscriptions.addAll(subscriptions);
+            newSubscriptions.remove(s); // only first occurrence
+            return new State(isUnsubscribed, newSubscriptions);
+        }
+
+        State clear() {
+            return new State(isUnsubscribed, new ArrayList());
+        }
+    }
 
     public CompositeSubscription(final Subscription... subscriptions) {
-        reference.set(new HashSet(asList(subscriptions)));
+        state.set(new State(false, Arrays.asList(subscriptions)));
     }
 
     public boolean isUnsubscribed() {
-        return reference.get() == UNSUBSCRIBED_SENTINEL;
+        return state.get().isUnsubscribed;
     }
 
     public void add(final Subscription s) {
+        State current;
+        State newState;
         do {
-            final Set existing = reference.get();
-            if (existing == UNSUBSCRIBED_SENTINEL) {
+            current = state.get();
+            if (current.isUnsubscribed) {
                 s.unsubscribe();
-                break;
-            }
-
-            if (existing == MUTATE_SENTINEL) {
-                continue;
+                return;
+            } else {
+                newState = current.add(s);
             }
-
-            if (reference.compareAndSet(existing, MUTATE_SENTINEL)) {
-                existing.add(s);
-                reference.set(existing);
-                break;
-            }
-        } while (true);
+        } while (!state.compareAndSet(current, newState));
     }
 
     public void remove(final Subscription s) {
+        State current;
+        State newState;
         do {
-            final Set subscriptions = reference.get();
-            if (subscriptions == UNSUBSCRIBED_SENTINEL) {
-                s.unsubscribe();
-                break;
-            }
-
-            if (subscriptions == MUTATE_SENTINEL) {
-                continue;
+            current = state.get();
+            if (current.isUnsubscribed) {
+                return;
+            } else {
+                newState = current.remove(s);
             }
-
-            if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) {
-                // also unsubscribe from it:
-                // http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable.remove(v=vs.103).aspx
-                subscriptions.remove(s);
-                reference.set(subscriptions);
-                s.unsubscribe();
-                break;
-            }
-        } while (true);
+        } while (!state.compareAndSet(current, newState));
+        // if we removed successfully we then need to call unsubscribe on it
+        s.unsubscribe();
     }
 
     public void clear() {
+        State current;
+        State newState;
         do {
-            final Set subscriptions = reference.get();
-            if (subscriptions == UNSUBSCRIBED_SENTINEL) {
-                break;
-            }
-
-            if (subscriptions == MUTATE_SENTINEL) {
-                continue;
+            current = state.get();
+            if (current.isUnsubscribed) {
+                return;
+            } else {
+                newState = current.clear();
             }
+        } while (!state.compareAndSet(current, newState));
+        // if we cleared successfully we then need to call unsubscribe on all previous
+        // current is now "previous"
+        unsubscribeFromAll(current.subscriptions);
+    }
 
-            if (reference.compareAndSet(subscriptions, MUTATE_SENTINEL)) {
-                final Set copy = new HashSet(
-                        subscriptions);
-                subscriptions.clear();
-                reference.set(subscriptions);
-
-                unsubscribeAll(copy);
-                break;
+    @Override
+    public void unsubscribe() {
+        State current;
+        State newState;
+        do {
+            current = state.get();
+            if (current.isUnsubscribed) {
+                return;
+            } else {
+                newState = current.unsubscribe();
             }
-        } while (true);
+        } while (!state.compareAndSet(current, newState));
+        // current is now "previous"
+        unsubscribeFromAll(current.subscriptions);
     }
 
-    /**
-     * Unsubscribe from the collection of subscriptions.
-     * 
    
-     * Exceptions thrown by any of the {@code unsubscribe()} methods are
-     * collected into a {@link CompositeException} and thrown once
-     * all unsubscriptions have been attempted.
-     * 
-     * @param subs
-     *            the collection of subscriptions
-     */
-    private void unsubscribeAll(Collection subs) {
+    private static void unsubscribeFromAll(Collection subscriptions) {
         final Collection es = new ArrayList();
-        for (final Subscription s : subs) {
+        for (Subscription s : subscriptions) {
             try {
                 s.unsubscribe();
-            } catch (final Throwable e) {
+            } catch (Throwable e) {
                 es.add(e);
             }
         }
@@ -140,23 +149,4 @@ private void unsubscribeAll(Collection subs) {
                     "Failed to unsubscribe to 1 or more subscriptions.", es);
         }
     }
-
-    @Override
-    public void unsubscribe() {
-        do {
-            final Set subscriptions = reference.get();
-            if (subscriptions == UNSUBSCRIBED_SENTINEL) {
-                break;
-            }
-
-            if (subscriptions == MUTATE_SENTINEL) {
-                continue;
-            }
-
-            if (reference.compareAndSet(subscriptions, UNSUBSCRIBED_SENTINEL)) {
-                unsubscribeAll(subscriptions);
-                break;
-            }
-        } while (true);
-    }
 }

From 591826561a931b25b0712c7d88793029d79c4cd1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 12:30:12 -0800
Subject: [PATCH 124/441] Refactor MultipleAssignment

- simplified state machine
---
 .../MultipleAssignmentSubscription.java       | 74 ++++++++++++++-----
 1 file changed, 54 insertions(+), 20 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index 9f734dcccf..f6a4da6c70 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -25,43 +25,77 @@
  * 
  * @see Rx.Net equivalent MultipleAssignmentDisposable
  */
-public class MultipleAssignmentSubscription implements Subscription {
-    private AtomicReference reference = new AtomicReference();
-    /** Sentinel for the unsubscribed state. */
-    private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() {
-        @Override
-        public void unsubscribe() {
+public final class MultipleAssignmentSubscription implements Subscription {
+
+    private final AtomicReference state = new AtomicReference(new State(false, Subscriptions.empty()));
+
+    private static final class State {
+        final boolean isUnsubscribed;
+        final Subscription subscription;
+
+        State(boolean u, Subscription s) {
+            this.isUnsubscribed = u;
+            this.subscription = s;
+        }
+
+        State unsubscribe() {
+            return new State(true, subscription);
         }
-    };
+
+        State set(Subscription s) {
+            return new State(isUnsubscribed, s);
+        }
+
+    }
 
     public boolean isUnsubscribed() {
-        return reference.get() == UNSUBSCRIBED_SENTINEL;
+        return state.get().isUnsubscribed;
     }
 
     @Override
     public void unsubscribe() {
-        Subscription s = reference.getAndSet(UNSUBSCRIBED_SENTINEL);
-        if (s != null) {
-            s.unsubscribe();
-        }
+        State oldState;
+        State newState;
+        do {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
+                return;
+            } else {
+                newState = oldState.unsubscribe();
+            }
+        } while (!state.compareAndSet(oldState, newState));
+        oldState.subscription.unsubscribe();
     }
 
+    @Deprecated
     public void setSubscription(Subscription s) {
+        set(s);
+    }
+
+    public void set(Subscription s) {
+        if (s == null) {
+            throw new IllegalArgumentException("Subscription can not be null");
+        }
+        State oldState;
+        State newState;
         do {
-            Subscription r = reference.get();
-            if (r == UNSUBSCRIBED_SENTINEL) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 s.unsubscribe();
                 return;
+            } else {
+                newState = oldState.set(s);
             }
-            if (reference.compareAndSet(r, s)) {
-                break;
-            }
-        } while (true);
+        } while (!state.compareAndSet(oldState, newState));
     }
 
+    @Deprecated
     public Subscription getSubscription() {
-        Subscription s = reference.get();
-        return s != UNSUBSCRIBED_SENTINEL ? s : Subscriptions.empty();
+        return get();
+    }
+
+    public Subscription get() {
+        return state.get().subscription;
     }
 
 }

From 996e78fa77962ad18c77675bbb6db2cb7c9a7889 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 12:30:54 -0800
Subject: [PATCH 125/441] Refactor SerialSubscription

- simplified state machine
---
 .../rx/subscriptions/SerialSubscription.java  | 85 +++++++++++++------
 1 file changed, 59 insertions(+), 26 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
index a0d8478130..73a27ca62f 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -15,8 +15,6 @@
  */
 package rx.subscriptions;
 
-import static rx.subscriptions.Subscriptions.empty;
-
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Subscription;
@@ -27,43 +25,78 @@
  * 
  * @see Rx.Net equivalent SerialDisposable
  */
-public class SerialSubscription implements Subscription {
-    private final AtomicReference reference = new AtomicReference(empty());
-    /** Sentinel for the unsubscribed state. */
-    private static final Subscription UNSUBSCRIBED_SENTINEL = new Subscription() {
-        @Override
-        public void unsubscribe() {
+public final class SerialSubscription implements Subscription {
+
+    private final AtomicReference state = new AtomicReference(new State(false, Subscriptions.empty()));
+
+    private static final class State {
+        final boolean isUnsubscribed;
+        final Subscription subscription;
+
+        State(boolean u, Subscription s) {
+            this.isUnsubscribed = u;
+            this.subscription = s;
+        }
+
+        State unsubscribe() {
+            return new State(true, subscription);
+        }
+
+        State set(Subscription s) {
+            return new State(isUnsubscribed, s);
         }
-    };
+
+    }
 
     public boolean isUnsubscribed() {
-        return reference.get() == UNSUBSCRIBED_SENTINEL;
+        return state.get().isUnsubscribed;
     }
 
     @Override
     public void unsubscribe() {
-        Subscription s = reference.getAndSet(UNSUBSCRIBED_SENTINEL);
-        if (s != null) {
-            s.unsubscribe();
-        }
+        State oldState;
+        State newState;
+        do {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
+                return;
+            } else {
+                newState = oldState.unsubscribe();
+            }
+        } while (!state.compareAndSet(oldState, newState));
+        oldState.subscription.unsubscribe();
+    }
+
+    @Deprecated
+    public void setSubscription(Subscription s) {
+        set(s);
     }
 
-    public void setSubscription(final Subscription subscription) {
+    public void set(Subscription s) {
+        if (s == null) {
+            throw new IllegalArgumentException("Subscription can not be null");
+        }
+        State oldState;
+        State newState;
         do {
-            final Subscription current = reference.get();
-            if (current == UNSUBSCRIBED_SENTINEL) {
-                subscription.unsubscribe();
-                break;
-            }
-            if (reference.compareAndSet(current, subscription)) {
-                current.unsubscribe();
-                break;
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
+                s.unsubscribe();
+                return;
+            } else {
+                newState = oldState.set(s);
             }
-        } while (true);
+        } while (!state.compareAndSet(oldState, newState));
+        oldState.subscription.unsubscribe();
     }
 
+    @Deprecated
     public Subscription getSubscription() {
-        final Subscription subscription = reference.get();
-        return subscription == UNSUBSCRIBED_SENTINEL ? Subscriptions.empty() : subscription;
+        return get();
     }
+
+    public Subscription get() {
+        return state.get().subscription;
+    }
+
 }

From 813988b67d518e27b5c011ed853cd0a08819de6a Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 12:32:07 -0800
Subject: [PATCH 126/441] Naming and Class Conventions

- make concrete implementations final as extending them is dangerous (use composition and implement Subscription instead)
- deprecated long get/setSubscription methods in favor of short verbs (add/get/set/clear/remove)
- updated unit tests with changes
---
 .../rx/subscriptions/BooleanSubscription.java |  2 +-
 .../subscriptions/CompositeSubscription.java  | 48 ++++++++---------
 .../subscriptions/RefCountSubscription.java   | 41 ++++++++-------
 .../java/rx/subscriptions/Subscriptions.java  |  2 +-
 .../MultipleAssignmentSubscriptionTest.java   | 52 ++++++++++++-------
 .../RefCountSubscriptionTest.java             | 10 ++--
 .../SerialSubscriptionTests.java              | 42 ++++++---------
 7 files changed, 101 insertions(+), 96 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
index 31c904e47f..d6dfedd549 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
@@ -26,7 +26,7 @@
  * 
  * @see Rx.Net equivalent BooleanDisposable
  */
-public class BooleanSubscription implements Subscription {
+public final class BooleanSubscription implements Subscription {
 
     private final AtomicBoolean unsubscribed = new AtomicBoolean(false);
     private final Action0 action;
diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 2b298c35b2..b0cf7cac23 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -30,7 +30,7 @@
  * 
  * @see Rx.Net equivalent CompositeDisposable
  */
-public class CompositeSubscription implements Subscription {
+public final class CompositeSubscription implements Subscription {
 
     private final AtomicReference state = new AtomicReference();
 
@@ -75,64 +75,62 @@ public boolean isUnsubscribed() {
     }
 
     public void add(final Subscription s) {
-        State current;
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 s.unsubscribe();
                 return;
             } else {
-                newState = current.add(s);
+                newState = oldState.add(s);
             }
-        } while (!state.compareAndSet(current, newState));
+        } while (!state.compareAndSet(oldState, newState));
     }
 
     public void remove(final Subscription s) {
-        State current;
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 return;
             } else {
-                newState = current.remove(s);
+                newState = oldState.remove(s);
             }
-        } while (!state.compareAndSet(current, newState));
+        } while (!state.compareAndSet(oldState, newState));
         // if we removed successfully we then need to call unsubscribe on it
         s.unsubscribe();
     }
 
     public void clear() {
-        State current;
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 return;
             } else {
-                newState = current.clear();
+                newState = oldState.clear();
             }
-        } while (!state.compareAndSet(current, newState));
+        } while (!state.compareAndSet(oldState, newState));
         // if we cleared successfully we then need to call unsubscribe on all previous
-        // current is now "previous"
-        unsubscribeFromAll(current.subscriptions);
+        unsubscribeFromAll(oldState.subscriptions);
     }
 
     @Override
     public void unsubscribe() {
-        State current;
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 return;
             } else {
-                newState = current.unsubscribe();
+                newState = oldState.unsubscribe();
             }
-        } while (!state.compareAndSet(current, newState));
-        // current is now "previous"
-        unsubscribeFromAll(current.subscriptions);
+        } while (!state.compareAndSet(oldState, newState));
+        unsubscribeFromAll(oldState.subscriptions);
     }
 
     private static void unsubscribeFromAll(Collection subscriptions) {
diff --git a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
index 091b9dcb1e..cb310e315e 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -26,10 +26,8 @@
  * 
  * @see MSDN RefCountDisposable
  */
-public class RefCountSubscription implements Subscription {
-    /** The reference to the actual subscription. */
+public final class RefCountSubscription implements Subscription {
     private final Subscription actual;
-    /** Counts the number of subscriptions (1 parent + multiple children) */
     private final AtomicReference state = new AtomicReference(new State(false, 0));
 
     private static final class State {
@@ -67,20 +65,25 @@ public RefCountSubscription(Subscription s) {
         this.actual = s;
     }
 
+    @Deprecated
+    public Subscription getSubscription() {
+        return get();
+    }
+
     /**
      * Returns a new sub-subscription.
      */
-    public Subscription getSubscription() {
-        State current;
+    public Subscription get() {
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 return Subscriptions.empty();
             } else {
-                newState = current.addChild();
+                newState = oldState.addChild();
             }
-        } while (!state.compareAndSet(current, newState));
+        } while (!state.compareAndSet(oldState, newState));
 
         return new InnerSubscription();
     }
@@ -94,15 +97,15 @@ public boolean isUnsubscribed() {
 
     @Override
     public void unsubscribe() {
-        State current;
+        State oldState;
         State newState;
         do {
-            current = state.get();
-            if (current.isUnsubscribed) {
+            oldState = state.get();
+            if (oldState.isUnsubscribed) {
                 return;
             }
-            newState = current.unsubscribe();
-        } while (!state.compareAndSet(current, newState));
+            newState = oldState.unsubscribe();
+        } while (!state.compareAndSet(oldState, newState));
         unsubscribeActualIfApplicable(newState);
     }
 
@@ -113,18 +116,18 @@ private void unsubscribeActualIfApplicable(State state) {
     }
 
     /** The individual sub-subscriptions. */
-    class InnerSubscription implements Subscription {
+    private final class InnerSubscription implements Subscription {
         final AtomicBoolean innerDone = new AtomicBoolean();
 
         @Override
         public void unsubscribe() {
             if (innerDone.compareAndSet(false, true)) {
-                State current;
+                State oldState;
                 State newState;
                 do {
-                    current = state.get();
-                    newState = current.removeChild();
-                } while (!state.compareAndSet(current, newState));
+                    oldState = state.get();
+                    newState = oldState.removeChild();
+                } while (!state.compareAndSet(oldState, newState));
                 unsubscribeActualIfApplicable(newState);
             }
         }
diff --git a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
index 61fd6b3f6c..c636184dad 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
@@ -24,7 +24,7 @@
 /**
  * Helper methods and utilities for creating and working with {@link Subscription} objects
  */
-public class Subscriptions {
+public final class Subscriptions {
     /**
      * A {@link Subscription} that does nothing.
      * 
diff --git a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index 9fbed89153..3f82df5891 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -15,54 +15,66 @@
  */
 package rx.subscriptions;
 
+import static org.mockito.Mockito.*;
+import static rx.subscriptions.Subscriptions.*;
 import junit.framework.Assert;
+
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+
 import rx.Subscription;
-import static rx.subscriptions.Subscriptions.create;
 import rx.util.functions.Action0;
 
 public class MultipleAssignmentSubscriptionTest {
+
     Action0 unsubscribe;
     Subscription s;
+
     @Before
     public void before() {
-         unsubscribe = mock(Action0.class);
-         s = create(unsubscribe);
+        unsubscribe = mock(Action0.class);
+        s = create(unsubscribe);
     }
+
     @Test
     public void testNoUnsubscribeWhenReplaced() {
         MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-        
-        mas.setSubscription(s);
-        mas.setSubscription(null);
-        mas.unsubscribe();        
-        
+
+        mas.set(s);
+        mas.set(Subscriptions.empty());
+        mas.unsubscribe();
+
         verify(unsubscribe, never()).call();
-        
     }
+
     @Test
     public void testUnsubscribeWhenParentUnsubscribes() {
         MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-        mas.setSubscription(s);
+        mas.set(s);
         mas.unsubscribe();
         mas.unsubscribe();
-        
+
         verify(unsubscribe, times(1)).call();
-        
+
         Assert.assertEquals(true, mas.isUnsubscribed());
     }
+
     @Test
-    public void testUnsubscribedDoesntLeakSentinel() {
+    public void subscribingWhenUnsubscribedCausesImmediateUnsubscription() {
         MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+        mas.unsubscribe();
+        Subscription underlying = mock(Subscription.class);
+        mas.set(underlying);
+        verify(underlying).unsubscribe();
+    }
 
-        mas.setSubscription(s);
+    @Test
+    public void testSubscriptionRemainsAfterUnsubscribe() {
+        MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+
+        mas.set(s);
         mas.unsubscribe();
-        
-        Assert.assertEquals(true, mas.getSubscription() == Subscriptions.empty());
+
+        Assert.assertEquals(true, mas.get() == s);
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
index d11899f903..4d4cec95e1 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
@@ -47,7 +47,7 @@ public void testImmediateUnsubscribe() {
     public void testRCSUnsubscribeBeforeClient() {
         InOrder inOrder = inOrder(main);
         
-        Subscription s = rcs.getSubscription();
+        Subscription s = rcs.get();
         
         rcs.unsubscribe();
         
@@ -67,8 +67,8 @@ public void testRCSUnsubscribeBeforeClient() {
     public void testMultipleClientsUnsubscribeFirst() {
         InOrder inOrder = inOrder(main);
 
-        Subscription s1 = rcs.getSubscription();
-        Subscription s2 = rcs.getSubscription();
+        Subscription s1 = rcs.get();
+        Subscription s2 = rcs.get();
 
         s1.unsubscribe();
         inOrder.verify(main, never()).call();
@@ -88,8 +88,8 @@ public void testMultipleClientsUnsubscribeFirst() {
     public void testMultipleClientsMainUnsubscribeFirst() {
         InOrder inOrder = inOrder(main);
 
-        Subscription s1 = rcs.getSubscription();
-        Subscription s2 = rcs.getSubscription();
+        Subscription s1 = rcs.get();
+        Subscription s2 = rcs.get();
 
         rcs.unsubscribe();
         inOrder.verify(main, never()).call();
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
index 4afadb6f9c..9459242549 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
@@ -49,28 +49,20 @@ public void unsubscribingWithoutUnderlyingDoesNothing() {
     }
 
     @Test
-    public void getSubscriptionShouldReturnEmptySubscriptionAfterUnsubscribe() {
+    public void getSubscriptionShouldReturnset() {
         final Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
-        serialSubscription.unsubscribe();
-        assertEquals(Subscriptions.empty(), serialSubscription.getSubscription());
-    }
-
-    @Test
-    public void getSubscriptionShouldReturnSetSubscription() {
-        final Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
-        assertSame(underlying, serialSubscription.getSubscription());
+        serialSubscription.set(underlying);
+        assertSame(underlying, serialSubscription.get());
 
         final Subscription another = mock(Subscription.class);
-        serialSubscription.setSubscription(another);
-        assertSame(another, serialSubscription.getSubscription());
+        serialSubscription.set(another);
+        assertSame(another, serialSubscription.get());
     }
 
     @Test
     public void unsubscribingTwiceDoesUnsubscribeOnce() {
         Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
 
         serialSubscription.unsubscribe();
         verify(underlying).unsubscribe();
@@ -82,16 +74,16 @@ public void unsubscribingTwiceDoesUnsubscribeOnce() {
     @Test
     public void settingSameSubscriptionTwiceDoesUnsubscribeIt() {
         Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
         verifyZeroInteractions(underlying);
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
         verify(underlying).unsubscribe();
     }
 
     @Test
     public void unsubscribingWithSingleUnderlyingUnsubscribes() {
         Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
         underlying.unsubscribe();
         verify(underlying).unsubscribe();
     }
@@ -99,18 +91,18 @@ public void unsubscribingWithSingleUnderlyingUnsubscribes() {
     @Test
     public void replacingFirstUnderlyingCausesUnsubscription() {
         Subscription first = mock(Subscription.class);
-        serialSubscription.setSubscription(first);
+        serialSubscription.set(first);
         Subscription second = mock(Subscription.class);
-        serialSubscription.setSubscription(second);
+        serialSubscription.set(second);
         verify(first).unsubscribe();
     }
 
     @Test
     public void whenUnsubscribingSecondUnderlyingUnsubscribed() {
         Subscription first = mock(Subscription.class);
-        serialSubscription.setSubscription(first);
+        serialSubscription.set(first);
         Subscription second = mock(Subscription.class);
-        serialSubscription.setSubscription(second);
+        serialSubscription.set(second);
         serialSubscription.unsubscribe();
         verify(second).unsubscribe();
     }
@@ -119,7 +111,7 @@ public void whenUnsubscribingSecondUnderlyingUnsubscribed() {
     public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscription() {
         serialSubscription.unsubscribe();
         Subscription underlying = mock(Subscription.class);
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
         verify(underlying).unsubscribe();
     }
 
@@ -127,7 +119,7 @@ public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscription() {
     public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscriptionConcurrently()
             throws InterruptedException {
         final Subscription firstSet = mock(Subscription.class);
-        serialSubscription.setSubscription(firstSet);
+        serialSubscription.set(firstSet);
 
         final CountDownLatch start = new CountDownLatch(1);
 
@@ -155,7 +147,7 @@ public void run() {
 
         final Subscription underlying = mock(Subscription.class);
         start.countDown();
-        serialSubscription.setSubscription(underlying);
+        serialSubscription.set(underlying);
         end.await();
         verify(firstSet).unsubscribe();
         verify(underlying).unsubscribe();
@@ -184,7 +176,7 @@ public void concurrentSetSubscriptionShouldNotInterleave()
                 public void run() {
                     try {
                         start.await();
-                        serialSubscription.setSubscription(subscription);
+                        serialSubscription.set(subscription);
                     } catch (InterruptedException e) {
                         fail(e.getMessage());
                     } finally {

From d914b7cd2773cbdeff3d0d25f95dbdb092287f8b Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Mon, 23 Dec 2013 23:20:02 +0100
Subject: [PATCH 127/441] Operation AsObservable

---
 rxjava-core/src/main/java/rx/Observable.java  |  9 +++++
 .../rx/operators/OperationAsObservable.java   | 37 +++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperationAsObservable.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f9dd5b9428..989247ea61 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -35,6 +35,7 @@
 import rx.operators.OperationAll;
 import rx.operators.OperationAmb;
 import rx.operators.OperationAny;
+import rx.operators.OperationAsObservable;
 import rx.operators.OperationAverage;
 import rx.operators.OperationBuffer;
 import rx.operators.OperationCache;
@@ -511,6 +512,14 @@ public Subscription subscribe(final Action1 onNext, final Action1 asObservable() {
+         return create(new OperationAsObservable(this));
+     }
+    
     /**
      * Returns a {@link ConnectableObservable} that upon connection causes the
      * source Observable to push results into the specified subject.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
new file mode 100644
index 0000000000..e753bb395e
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
@@ -0,0 +1,37 @@
+/**
+ * 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 rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+
+/**
+ * Hides the identity of another observable.
+ * @param  the return value type of the wrapped observable.
+ */
+public final class OperationAsObservable implements OnSubscribeFunc {
+    private final Observable source;
+
+    public OperationAsObservable(Observable source) {
+        this.source = source;
+    }
+    @Override
+    public Subscription onSubscribe(Observer t1) {
+        return source.subscribe(t1);
+    }
+}

From add6c293cdf1f351543963dfa2edbbae60e35b3f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 15:41:32 -0800
Subject: [PATCH 128/441] Alias from switchOnNext to switchLatest to match RxJS

- keeping onNext to be locally consistent with doOnNext
---
 rxjava-core/src/main/java/rx/Observable.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f9dd5b9428..e625d5d9ac 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1930,6 +1930,23 @@ public static  Observable switchDo(Observable Observable switchOnNext(Observable> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
+    
+    /**
+     * Given an Observable that emits Observables, returns an Observable that
+     * emits the items emitted by the most recently emitted of those
+     * Observables.
+     * 
    
+     * 
+     * 
+     * @param sequenceOfSequences the source Observable that emits Observables
+     * @return an Observable that emits only the items emitted by the Observable
+     *         most recently emitted by the source Observable
+     * @see RxJava Wiki: switchOnNext()
+     * @see {@link #switchOnNext(Observable)}
+     */
+    public static  Observable switchLatest(Observable> sequenceOfSequences) {
+        return create(OperationSwitch.switchDo(sequenceOfSequences));
+    }
 
     /**
      * Return an Observable that subscribes to an observable sequence

From 0689479d08f1bf0d504ec45573b15a027cc9bf52 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 15:41:56 -0800
Subject: [PATCH 129/441] doOnNext, doOnCompleted, doOnError, doOnEach

---
 rxjava-core/src/main/java/rx/Observable.java | 87 ++++++--------------
 1 file changed, 25 insertions(+), 62 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e625d5d9ac..b6a0e18c1d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1054,7 +1054,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     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.
@@ -6571,36 +6571,6 @@ public Observable doOnEach(Observer observer) {
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
-    /**
-     * Invokes an action for each item emitted by an Observable.
-     * 
    
-     * 
-     *
-     * @param onNext the action to invoke for each item emitted by the source
-     *               Observable
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnEach()
-     * @see MSDN: Observable.Do
-     */
-    public Observable doOnEach(final Action1 onNext) {
-        Observer observer = new Observer() {
-            @Override
-            public void onCompleted() {}
-
-            @Override
-            public void onError(Throwable e) {}
-
-            @Override
-            public void onNext(T args) {
-                onNext.call(args);
-            }
-
-        };
-
-
-        return create(OperationDoOnEach.doOnEach(this, observer));
-    }
-    
     /**
      * Invokes an action if the source Observable calls onError.
      * 
    
@@ -6661,71 +6631,64 @@ public void onNext(T args) { }
 
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
-
+    
+    
     /**
-     * Invokes an action for each item emitted by an Observable.
+     * Invokes an action when the source Observable calls
+     * onNext.
      * 
    
-     * 
+     * 
      *
-     * @param onNext the action to invoke for each item emitted by the
-     *               Observable
-     * @param onError the action to invoke when the source Observable calls
-     *                onError
+     * @param onCompleted the action to invoke when the source Observable calls
+     *                    onCompleted
      * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnEach()
-     * @see MSDN: Observable.Do
+     * @see RxJava Wiki: doOnNext()
+     * @see MSDN: Observable.Do
      */
-    public Observable doOnEach(final Action1 onNext, final Action1 onError) {
+    public Observable doOnNext(final Action1 onNext) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {}
+            public void onCompleted() { }
 
             @Override
-            public void onError(Throwable e) {
-                onError.call(e);
-            }
+            public void onError(Throwable e) { }
 
             @Override
-            public void onNext(T args) {
+            public void onNext(T args) { 
                 onNext.call(args);
             }
 
         };
 
-
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
-
+    
     /**
-     * Invokes an action for each item emitted by an Observable.
+     * Invokes an action for each item emitted by the Observable.
      * 
    
-     * 
+     * 
      *
-     * @param onNext the action to invoke for each item emitted by the
-     *               Observable
-     * @param onError the action to invoke when the source Observable calls
-     *                onError
-     * @param onCompleted the action to invoke when the source Observable calls
-     *                    onCompleted
+     * @param observer the action to invoke for each item emitted by the source
+     *                 Observable
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnEach()
-     * @see MSDN: Observable.Do
+     * @see MSDN: Observable.Do
      */
-    public Observable doOnEach(final Action1 onNext, final Action1 onError, final Action0 onCompleted) {
+    public Observable doOnEach(final Action1> onNotification) {
         Observer observer = new Observer() {
             @Override
             public void onCompleted() {
-                onCompleted.call();
+                onNotification.call(new Notification());
             }
 
             @Override
             public void onError(Throwable e) {
-                onError.call(e);
+                onNotification.call(new Notification(e));
             }
 
             @Override
-            public void onNext(T args) {
-                onNext.call(args);
+            public void onNext(T v) {
+                onNotification.call(new Notification(v));
             }
 
         };

From eb295958e13bf16ae0b91149b1745e1b7998f3b9 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Tue, 24 Dec 2013 00:48:21 +0100
Subject: [PATCH 130/441] Operators Skip, SkipLast, Take with time

---
 rxjava-core/src/main/java/rx/Observable.java  |  73 ++++++++++
 .../main/java/rx/operators/OperationSkip.java |  87 ++++++++++++
 .../java/rx/operators/OperationSkipLast.java  |  75 ++++++++++
 .../main/java/rx/operators/OperationTake.java | 123 ++++++++++++++++
 .../java/rx/operators/OperationTakeLast.java  |   5 +-
 .../rx/operators/OperationSkipLastTest.java   |  97 ++++++++++++-
 .../java/rx/operators/OperationSkipTest.java  | 132 +++++++++++++++++-
 .../java/rx/operators/OperationTakeTest.java  | 100 ++++++++++++-
 8 files changed, 686 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f9dd5b9428..8ba9944cb8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5246,6 +5246,29 @@ public Observable skip(int num) {
         return create(OperationSkip.skip(this, num));
     }
 
+    /**
+      * Create an Observable that skips values before the given time ellapses.
+      * @param time the length of the time window
+      * @param unit the time unit
+      * @return an Observable that skips values before the given time ellapses
+      */
+     public Observable skip(long time, TimeUnit unit) {
+         return skip(time, unit, Schedulers.threadPoolForComputation());
+     }
+ 
+     /**
+      * Create an Observable that skips values before the given time
+      * elapses while waiting on the given scheduler.
+      * @param time the length of the time window
+      * @param unit the time unit
+      * @param scheduler the scheduler where the timed wait happens
+      * @return an Observable that skips values before the given time
+      * elapses while waiting on the given scheduler
+      */
+     public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
+         return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
+     }
+ 
     /**
      * If the Observable completes after emitting a single item, return an
      * Observable containing that item. If it emits more than one item or no
@@ -5426,6 +5449,31 @@ public Observable take(final int num) {
         return create(OperationTake.take(this, num));
     }
 
+    /**
+      * Create an Observable that takes the emitted values of the source
+      * Observable before the time runs out.
+      * @param time the length of the time window
+      * @param unit the time unit
+      * @return an Observable that takes the emitted values of the source
+      *         Observable before the time runs out.
+      */
+     public Observable take(long time, TimeUnit unit) {
+         return take(time, unit, Schedulers.threadPoolForComputation());
+     }
+     
+     /**
+      * Create an Observable that takes the emitted values of the source
+      * Observable before the time runs out, waiting on the given scheduler.
+      * @param time the length of the time window
+      * @param unit the time unit
+      * @param scheduler the scheduler used for time source
+      * @return an Observable that takes the emitted values of the source
+      *         Observable before the time runs out, waiting on the given scheduler.
+      */
+     public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
+         return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
+     }
+ 
     /**
      * Returns an Observable that emits items emitted by the source Observable
      * so long as a specified condition is true.
@@ -5734,6 +5782,31 @@ public Observable skipLast(int count) {
         return create(OperationSkipLast.skipLast(this, count));
     }
 
+    /**
+     * Create an observable which skips values emitted in a time window
+     * before the source completes.
+     * @param time the length of the time window
+     * @param unit the time unit
+     * @return an observable which skips values emitted in a time window
+     * before the source completes
+     */
+    public Observable skipLast(long time, TimeUnit unit) {
+        return skipLast(time, unit, Schedulers.threadPoolForComputation());
+    }
+    
+    /**
+     * Create an observable which skips values emitted in a time window
+     * before the source completes by using the given scheduler as time source.
+     * @param time the length of the time window
+     * @param unit the time unit
+     * @param scheduler the scheduler used for time source
+     * @return an observable which skips values emitted in a time window
+     * before the source completes by using the given scheduler as time source
+     */
+    public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
+    }
+ 
     /**
      * Returns an Observable that emits a single item, a list composed of all
      * the items emitted by the source Observable.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 4dc3359815..0b33fb0af9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -15,12 +15,17 @@
  */
 package rx.operators;
 
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Scheduler;
 import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.util.functions.Action0;
 
 /**
  * Returns an Observable that skips the first num items emitted by the source
@@ -107,4 +112,86 @@ public void onNext(T args) {
         }
 
     }
+    
+    /** 
+     * Skip the items after subscription for the given duration. 
+     * @param  the value type
+     */
+    public static final class SkipTimed implements OnSubscribeFunc {
+        final Observable source;
+        final long time;
+        final TimeUnit unit;
+        final Scheduler scheduler;
+
+        public SkipTimed(Observable source, long time, TimeUnit unit, Scheduler scheduler) {
+            this.source = source;
+            this.time = time;
+            this.unit = unit;
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            
+            SafeObservableSubscription timer = new SafeObservableSubscription();
+            SafeObservableSubscription data = new SafeObservableSubscription();
+
+            CompositeSubscription csub = new CompositeSubscription(timer, data);
+            
+            SourceObserver so = new SourceObserver(t1, csub);
+            data.wrap(source.subscribe(so));
+            if (!data.isUnsubscribed()) {
+                timer.wrap(scheduler.schedule(so, time, unit));
+            }
+            
+            return csub;
+        }
+        /**
+         * Observes the source and relays its values once gate turns into true.
+         * @param  the observed value type
+         */
+        private static final class SourceObserver implements Observer, Action0 {
+            final AtomicBoolean gate;
+            final Observer observer;
+            final Subscription cancel;
+
+            public SourceObserver(Observer observer, 
+                    Subscription cancel) {
+                this.gate = new AtomicBoolean();
+                this.observer = observer;
+                this.cancel = cancel;
+            }
+
+            @Override
+            public void onNext(T args) {
+                if (gate.get()) {
+                    observer.onNext(args);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    observer.onError(e);
+                } finally {
+                    cancel.unsubscribe();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                try {
+                    observer.onCompleted();
+                } finally {
+                    cancel.unsubscribe();
+                }
+            }
+            
+            @Override
+            public void call() {
+                gate.set(true);
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index f3cb462e55..a25186a4d1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -15,14 +15,20 @@
  */
 package rx.operators;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Deque;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Scheduler;
 import rx.Subscription;
+import rx.util.Timestamped;
 
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
@@ -123,4 +129,73 @@ public void onNext(T value) {
             }));
         }
     }
+    
+    /**
+     * Skip delivering values in the time window before the values.
+     * @param  the result value type
+     */
+    public static final class SkipLastTimed implements OnSubscribeFunc {
+        final Observable source;
+        final long timeInMillis;
+        final Scheduler scheduler;
+
+        public SkipLastTimed(Observable source, long time, TimeUnit unit, Scheduler scheduler) {
+            this.source = source;
+            this.timeInMillis = unit.toMillis(time);
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            return source.subscribe(new SourceObserver(t1, timeInMillis, scheduler));
+        }
+        /** Observes the source. */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final long timeInMillis;
+            final Scheduler scheduler;
+            List> buffer = new ArrayList>();
+
+            public SourceObserver(Observer observer, 
+                    long timeInMillis, Scheduler scheduler) {
+                this.observer = observer;
+                this.timeInMillis = timeInMillis;
+                this.scheduler = scheduler;
+            }
+
+            @Override
+            public void onNext(T args) {
+                buffer.add(new Timestamped(scheduler.now(), args));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                buffer = Collections.emptyList();
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                long limit = scheduler.now() - timeInMillis;
+                try {
+                    for (Timestamped v : buffer) {
+                        if (v.getTimestampMillis() < limit) {
+                            try {
+                                observer.onNext(v.getValue());
+                            } catch (Throwable t) {
+                                observer.onError(t);
+                                return;
+                            }
+                        } else {
+                            observer.onCompleted();
+                            break;
+                        }
+                    }
+                } finally {
+                    buffer = Collections.emptyList();
+                }
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTake.java b/rxjava-core/src/main/java/rx/operators/OperationTake.java
index 877ba4d5f3..797eb47d43 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTake.java
@@ -15,13 +15,17 @@
  */
 package rx.operators;
 
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Scheduler;
 import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 
 /**
  * Returns an Observable that emits the first num items emitted by the source
@@ -161,4 +165,123 @@ public void onNext(T args) {
         }
 
     }
+    
+    /**
+     * Takes values from the source until a timer fires.
+     * @param  the result value type
+     */
+    public static final class TakeTimed implements OnSubscribeFunc {
+        final Observable source;
+        final long time;
+        final TimeUnit unit;
+        final Scheduler scheduler;
+
+        public TakeTimed(Observable source, long time, TimeUnit unit, Scheduler scheduler) {
+            this.source = source;
+            this.time = time;
+            this.unit = unit;
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            
+            SafeObservableSubscription timer = new SafeObservableSubscription();
+            SafeObservableSubscription data = new SafeObservableSubscription();
+
+            CompositeSubscription csub = new CompositeSubscription(timer, data);
+            
+            SourceObserver so = new SourceObserver(t1, csub);
+            data.wrap(source.subscribe(so));
+            if (!data.isUnsubscribed()) {
+                timer.wrap(scheduler.schedule(so, time, unit));
+            }
+            
+            return csub;
+        }
+        /**
+         * Observes the source and relays its values until gate turns into false.
+         * @param  the observed value type
+         */
+        private static final class SourceObserver implements Observer, Action0 {
+            final Observer observer;
+            final Subscription cancel;
+            final AtomicInteger state = new AtomicInteger();
+            static final int ACTIVE = 0;
+            static final int NEXT = 1;
+            static final int DONE = 2;
+
+            public SourceObserver(Observer observer, 
+                    Subscription cancel) {
+                this.observer = observer;
+                this.cancel = cancel;
+            }
+
+            @Override
+            public void onNext(T args) {
+                do {
+                    int s = state.get();
+                    if (s == DONE) {
+                        return;
+                    }
+                    if (state.compareAndSet(s, NEXT)) {
+                        try {
+                            observer.onNext(args);
+                        } finally {
+                            state.set(ACTIVE);
+                            return;
+                        }
+                    }
+                } while (true);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                do {
+                    int s = state.get();
+                    if (s == DONE) {
+                        return;
+                    } else
+                    if (s == NEXT) {
+                        continue;
+                    } else
+                    if (state.compareAndSet(s, DONE)) {
+                        try {
+                            observer.onError(e);
+                        } finally {
+                            cancel.unsubscribe();
+                        }
+                        return;
+                    }
+                } while (true);
+            }
+
+            @Override
+            public void onCompleted() {
+                do {
+                    int s = state.get();
+                    if (s == DONE) {
+                        return;
+                    } else
+                    if (s == NEXT) {
+                        continue;
+                    } else
+                    if (state.compareAndSet(s, DONE)) {
+                        try {
+                            observer.onCompleted();
+                        } finally {
+                            cancel.unsubscribe();
+                        }
+                        return;
+                    }
+                } while (true);
+            }
+
+            @Override
+            public void call() {
+                onCompleted();
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index c0558d43e1..cc7ebca74a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -25,7 +25,6 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.subscriptions.SingleAssignmentSubscription;
 import rx.util.Timestamped;
 
 /**
@@ -156,8 +155,8 @@ public TakeLastTimed(Observable source, int count, long time, TimeU
 
         @Override
         public Subscription onSubscribe(Observer t1) {
-            SingleAssignmentSubscription sas = new SingleAssignmentSubscription();
-            sas.set(source.subscribe(new TakeLastTimedObserver(t1, sas, count, ageMillis, scheduler)));
+            SafeObservableSubscription sas = new SafeObservableSubscription();
+            sas.wrap(source.subscribe(new TakeLastTimedObserver(t1, sas, count, ageMillis, scheduler)));
             return sas;
         }
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
index 9391424e07..27e1b1e126 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
+import java.util.concurrent.TimeUnit;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationSkipLast.*;
 
@@ -24,6 +24,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.concurrency.TestScheduler;
+import rx.operators.OperationSkipTest.CustomException;
+import rx.subjects.PublishSubject;
 
 public class OperationSkipLastTest {
 
@@ -111,4 +114,96 @@ public void testSkipLastWithNegativeCount() {
                 any(IndexOutOfBoundsException.class));
         verify(aObserver, never()).onCompleted();
     }
+    
+    @Test
+    public void testSkipLastTimed() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
+        
+        source.onNext(4);
+        source.onNext(5);
+        source.onNext(6);
+
+        scheduler.advanceTimeBy(950, TimeUnit.MILLISECONDS);
+        source.onCompleted();
+                
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o, never()).onNext(4);
+        inOrder.verify(o, never()).onNext(5);
+        inOrder.verify(o, never()).onNext(6);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testSkipLastTimedErrorBeforeTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onError(new OperationSkipTest.CustomException());
+        
+        scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
+
+        verify(o).onError(any(CustomException.class));
+     
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+    }
+    
+    @Test
+    public void testSkipLastTimedCompleteBeforeTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+
+        scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
+        
+        source.onCompleted();
+        
+        
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onError(any(Throwable.class));
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
index 16bc76820f..44f08d2402 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
@@ -15,14 +15,17 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
+import java.util.concurrent.TimeUnit;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationSkip.*;
 
 import org.junit.Test;
+import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observer;
+import rx.concurrency.TestScheduler;
+import rx.subjects.PublishSubject;
 
 public class OperationSkipTest {
 
@@ -55,4 +58,131 @@ public void testSkip2() {
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, times(1)).onCompleted();
     }
+    
+    @Test
+    public void testSkipTimed() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(4);
+        source.onNext(5);
+        source.onNext(6);
+        
+        source.onCompleted();
+        
+        InOrder inOrder = inOrder(o);
+        
+        inOrder.verify(o, never()).onNext(1);
+        inOrder.verify(o, never()).onNext(2);
+        inOrder.verify(o, never()).onNext(3);
+        inOrder.verify(o).onNext(4);
+        inOrder.verify(o).onNext(5);
+        inOrder.verify(o).onNext(6);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testSkipTimedFinishBeforeTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onCompleted();
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        InOrder inOrder = inOrder(o);
+        
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    static class CustomException extends RuntimeException { }
+    @Test
+    public void testSkipTimedErrorBeforeTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onError(new CustomException());
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        InOrder inOrder = inOrder(o);
+        
+        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testSkipTimedErrorAfterTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(4);
+        source.onNext(5);
+        source.onNext(6);
+        
+        source.onError(new CustomException());
+        
+        InOrder inOrder = inOrder(o);
+        
+        inOrder.verify(o, never()).onNext(1);
+        inOrder.verify(o, never()).onNext(2);
+        inOrder.verify(o, never()).onNext(3);
+        inOrder.verify(o).onNext(4);
+        inOrder.verify(o).onNext(5);
+        inOrder.verify(o).onNext(6);
+        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onCompleted();
+        
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
index 773154eda0..988ffa062e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
@@ -15,8 +15,8 @@
  */
 package rx.operators;
 
+import java.util.concurrent.TimeUnit;
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationTake.*;
 
@@ -28,6 +28,9 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.operators.OperationSkipTest.CustomException;
+import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func1;
 
@@ -224,4 +227,99 @@ public void run() {
             return s;
         }
     }
+    
+    @Test
+    public void testTakeTimed() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(4);
+        
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onNext(4);
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testTakeTimedErrorBeforeTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onError(new CustomException());
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(4);
+        
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(4);
+    }
+    
+    @Test
+    public void testTakeTimedErrorAfterTime() {
+        TestScheduler scheduler = new TestScheduler();
+        
+        PublishSubject source = PublishSubject.create();
+        
+        Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
+        
+        Observer o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(4);
+        source.onError(new CustomException());
+        
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onNext(4);
+        verify(o, never()).onError(any(CustomException.class));
+    }
 }

From 140fc706a55a6c50e942f3763905aad0acc95a22 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Mon, 23 Dec 2013 17:12:15 -0800
Subject: [PATCH 131/441] Javadoc improvements: * diagrams for switchCase,
 doWhile, whileDo, ifThen, delaySubscription, single, singleOrDefault,
 takeFirst, takeLast (and variant forms of these) * standardizing javadoc
 comment formatting * standardizing nomenclature

---
 rxjava-core/src/main/java/rx/Observable.java  | 499 ++++++++++--------
 .../main/java/rx/subjects/AsyncSubject.java   |   2 +-
 .../java/rx/subjects/BehaviorSubject.java     |   2 +-
 .../main/java/rx/subjects/PublishSubject.java |   2 +-
 4 files changed, 296 insertions(+), 209 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f9dd5b9428..135a68dfaa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1932,16 +1932,19 @@ public static  Observable switchOnNext(Observable
+     * 
+     *
      * @param  the case key type
      * @param  the result value type
-     * @param caseSelector the function that produces a case key when an Observer subscribes
-     * @param mapOfCases a map that maps a case key to an observable sequence
-     * @return an Observable that subscribes to an observable sequence
-     *         chosen from a map of observables via a selector function or to an
-     *         empty observable
+     * @param caseSelector the function that produces a case key when an
+     *                     Observer subscribes
+     * @param mapOfCases a map that maps a case key to an Observable
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or an empty Observable if no Observable matches the
+     *         key
      */
     public static  Observable switchCase(Func0 caseSelector, 
             Map> mapOfCases) {
@@ -1949,35 +1952,41 @@ public static  Observable switchCase(Func0 caseSelector,
     }
     
     /**
-     * Return an Observable that subscribes to an observable sequence
-     * chosen from a map of observables via a selector function or to an
-     * empty observable which runs on the given scheduler.
+     * Return a particular one of several possible Observables based on a case
+     * selector and run it on the designated scheduler.
+     * 
    
+     * 
+     *
      * @param  the case key type
      * @param  the result value type
      * @param caseSelector the function that produces a case key when an Observer subscribes
-     * @param mapOfCases a map that maps a case key to an observable sequence
+     * @param mapOfCases a map that maps a case key to an Observable
      * @param scheduler the scheduler where the empty observable is observed
-     * @return an Observable that subscribes to an observable sequence
-     *         chosen from a map of observables via a selector function or to an
-     *         empty observable which runs on the given scheduler
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or an empty Observable if no Observable matches the
+     *         key, but one that runs on the designated scheduler in either case
      */
     public static  Observable switchCase(Func0 caseSelector, 
             Map> mapOfCases, Scheduler scheduler) {
         return switchCase(caseSelector, mapOfCases, Observable.empty(scheduler));
     }
     /**
-     * Return an Observable that subscribes to an observable sequence
-     * chosen from a map of observables via a selector function or to the
-     * default observable.
+     * Return a particular one of several possible Observables based on a case
+     * selector, or a default Observable if the case selector does not map to
+     * a particular one.
+     * 
    
+     * 
+     *
      * @param  the case key type
      * @param  the result value type
-     * @param caseSelector the function that produces a case key when an Observer subscribes
-     * @param mapOfCases a map that maps a case key to an observable sequence
-     * @param defaultCase the default observable if the {@code mapOfCases} doesn't contain a value for
-     *                    the key returned by the {@case caseSelector}
-     * @return an Observable that subscribes to an observable sequence
-     *         chosen from a map of observables via a selector function or to an
-     *         empty observable
+     * @param caseSelector the function that produces a case key when an
+     *                     Observer subscribes
+     * @param mapOfCases a map that maps a case key to an Observable
+     * @param defaultCase the default Observable if the {@code mapOfCases}
+     *                    doesn't contain a value for the key returned by the
+     *                    {@case caseSelector}
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or the default case if no Observable matches the key
      */
     public static  Observable switchCase(Func0 caseSelector, 
             Map> mapOfCases, 
@@ -1986,67 +1995,94 @@ public static  Observable switchCase(Func0 caseSelector,
     }
     
     /**
-     * Return an Observable that subscribes to the this Observable,
-     * then resubscribes only if the postCondition evaluates to true.
-     * @param postCondition the post condition after the source completes
-     * @return an Observable that subscribes to the source Observable,
-     * then resubscribes only if the postCondition evaluates to true.
+     * Return an Observable that replays the emissions from the source
+     * Observable, and then continues to replay them so long as a condtion is
+     * true.
+     * 
    
+     * 
+     *
+     * @param postCondition the post condition to test after the source
+     *                      Observable completes
+     * @return an Observable that replays the emissions from the source
+     *         Observable, and then continues to replay them so long as the post
+     *         condition is true
      */
     public Observable doWhile(Func0 postCondition) {
         return create(OperationConditionals.doWhile(this, postCondition));
     }
     
     /**
-     * Return an Observable that subscribes and resubscribes to this
-     * Observable if the preCondition evaluates to true.
-     * @param preCondition the condition to evaluate before subscribing to this, 
-     *                     and subscribe to source if it returns {@code true}
-     * @return an Observable that subscribes and resubscribes to the source
-     * Observable if the preCondition evaluates to true.
+     * Return an Observable that replays the emissions from the source
+     * Observable so long as a condtion is true.
+     * 
    
+     * 
+     *
+     * @param preCondition the condition to evaluate before subscribing to or
+     *                     replaying the source Observable
+     * @return an Observable that replays the emissions from the source
+     *         Observable so long as preCondition is true
      */
     public Observable whileDo(Func0 preCondition) {
         return create(OperationConditionals.whileDo(this, preCondition));
     }
     
     /**
-     * Return an Observable that subscribes to the
-     * then Observables if the condition function evaluates to true, or to an empty
-     * Observable if false.
+     * Return an Observable that emits the emissions from a specified Observable
+     * if a condition evaluates to true, otherwise return an empty Observable.
+     * 
    
+     * 
+     *
      * @param  the result value type
-     * @param condition the condition to decide which Observables to subscribe to
-     * @param then the Observable sequence to subscribe to if {@code condition} is {@code true}
-     * @return an Observable that subscribes to the
-     *         then Observables if the condition function evaluates to true, or to an empty
-     *         Observable running on the given scheduler if false
+     * @param condition the condition that decides whether to emit the emissions
+     *                  from the then Observable
+     * @param then the Observable sequence to emit to if {@code condition} is
+     *             {@code true}
+     * @return an Observable that mimics the {@code then} Observable if the
+     *         {@code condition} function evaluates to true, or an empty
+     *         Observable otherwise
      */
     public static  Observable ifThen(Func0 condition, Observable then) {
         return ifThen(condition, then, Observable.empty());
     }
     
     /**
-     * Return an Observable that subscribes to the
-     * then Observables if the condition function evaluates to true, or to an empty
-     * Observable running on the given scheduler if false.
+     * Return an Observable that emits the emissions from a specified Observable
+     * if a condition evaluates to true, otherwise return an empty Observable
+     * that runs on a specified Scheduler.
+     * 
    
+     * 
+     *
      * @param  the result value type
-     * @param condition the condition to decide which Observables to subscribe to
-     * @param then the Observable sequence to subscribe to if {@code condition} is {@code true}
-     * @param scheduler the scheduler where the empty Observable is observed in case the condition returns false
-     * @return an Observable that subscribes to the
-     *         then Observables if the condition function evaluates to true, or to an empty
-     *         Observable running on the given scheduler if false
+     * @param condition the condition that decides whether to emit the emissions
+     *                  from the then Observable
+     * @param then the Observable sequence to emit to if {@code condition} is
+     *             {@code true}
+     * @param scheduler the Scheduler on which the empty Observable runs if the
+     *                  in case the condition returns false
+     * @return an Observable that mimics the {@code then} Observable if the
+     *         {@code condition} function evaluates to true, or an empty
+     *         Observable running on the specified Scheduler otherwise
      */
     public static  Observable ifThen(Func0 condition, Observable then, Scheduler scheduler) {
         return ifThen(condition, then, Observable.empty(scheduler));
     }
+
     /**
-     * Return an Observable that subscribes to either the
-     * then or orElse Observables depending on a condition function.
+     * Return an Observable that emits the emissions from one specified
+     * Observable if a condition evaluates to true, or from another specified
+     * Observable otherwise.
+     * 
    
+     * 
+     *
      * @param  the result value type
-     * @param condition the condition to decide which Observables to subscribe to
-     * @param then the Observable sequence to subscribe to if {@code condition} is {@code true}
-     * @param orElse the Observable sequence to subscribe to if {@code condition} is {@code false}
-     * @return an Observable that subscribes to either the
-     *         then or orElse Observables depending on a condition function
+     * @param condition the condition that decides which Observable to emit the
+     *                  emissions from
+     * @param then the Observable sequence to emit to if {@code condition} is
+     *             {@code true}
+     * @param orElse the Observable sequence to emit to if {@code condition} is
+     *               {@code false}
+     * @return an Observable that mimics either the {@code then} or
+     *         {@code orElse} Observables depending on a condition function
      */
     public static  Observable ifThen(Func0 condition, Observable then,
             Observable orElse) {
@@ -2254,25 +2290,34 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
     }
 
     /**
-     * Return an Observable which delays the subscription to this Observable sequence
-     * by the given amount.
+     * Return an Observable that delays the subscription to the source
+     * Observable by a given amount of time.
+     * 
    
+     * 
+     *
      * @param delay the time to delay the subscription
      * @param unit the time unit
-     * @return an Observable which delays the subscription to this Observable sequence
-     *         by the given amount.
+     * @return an Observable that delays the subscription to the source
+     *         Observable by the given amount
      */
     public Observable delaySubscription(long delay, TimeUnit unit) {
         return delaySubscription(delay, unit, Schedulers.threadPoolForComputation());
     }
     
     /**
-     * Return an Observable which delays the subscription to this Observable sequence
-     * by the given amount, waiting and subscribing on the given scheduler.
+     * Return an Observable that delays the subscription to the source
+     * Observable by a given amount of time, both waiting and subscribing on
+     * a given Scheduler.
+     * 
    
+     * 
+     *
      * @param delay the time to delay the subscription
      * @param unit the time unit
-     * @param scheduler the scheduler where the waiting and subscription will happen
-     * @return an Observable which delays the subscription to this Observable sequence
-     *         by the given amount, waiting and subscribing on the given scheduler
+     * @param scheduler the scheduler on which the waiting and subscription will
+     *                  happen
+     * @return an Observable that delays the subscription to the source
+     *         Observable by a given amount, waiting and subscribing on the
+     *         given Scheduler
      */
     public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(OperationDelay.delaySubscription(this, delay, unit, scheduler));
@@ -5247,14 +5292,16 @@ public Observable skip(int num) {
     }
 
     /**
-     * If the Observable completes after emitting a single item, return an
-     * Observable containing that item. If it emits more than one item or no
-     * item, throw an IllegalArgumentException.
+     * If the source Observable completes after emitting a single item, return
+     * an Observable that emits that item. If the source Observable emits more
+     * than one item or no items, throw an IllegalArgumentException.
+     * 
    
+     * 
      * 
-     * @return an Observable containing the single item emitted by the source
-     *         Observable that matches the predicate.
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item or no item
+     * @return an Observable that emits the single item emitted by the source
+     *         Observable that matches the predicate
+     * @throws IllegalArgumentException if the source emits more than one item
+     *                                  or no items
      */
     public Observable single() {
         return create(OperationSingle. single(this));
@@ -5262,35 +5309,37 @@ public Observable single() {
 
     /**
      * If the Observable completes after emitting a single item that matches a
-     * predicate, return an Observable containing that item. If it emits more
-     * than one such item or no item, throw an IllegalArgumentException.
-     * 
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the source
-     *            Observable
-     * @return an Observable containing the single item emitted by the source
-     *         Observable that matches the predicate.
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item or no item matching
-     *             the predicate
+     * predicate, return an Observable that emits that item. If the source
+     * Observable emits more than one such item or no such items, throw an
+     * IllegalArgumentException.
+     * 
    
+     * 
+     * 
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  source Observable
+     * @return an Observable that emits the single item emitted by the source
+     *         Observable that matches the predicate
+     * @throws IllegalArgumentException if the source Observable emits more than
+     *                                  one item or no items matching the
+     *                                  predicate
      */
     public Observable single(Func1 predicate) {
         return filter(predicate).single();
     }
 
     /**
-     * If the Observable completes after emitting a single item, return an
-     * Observable containing that item. If it's empty, return an Observable
-     * containing the defaultValue. If it emits more than one item, throw an
-     * IllegalArgumentException.
+     * If the source Observable completes after emitting a single item, return
+     * an Observable that emits that item. If the source Observable is empty,
+     * return an Observable that emits a default item. If the source Observable
+     * emits more than one item, throw an IllegalArgumentException.
+     * 
    
+     * 
      * 
-     * @param defaultValue
-     *            a default value to return if the Observable emits no item
-     * @return an Observable containing the single item emitted by the source
-     *         Observable, or an Observable containing the defaultValue if no
-     *         item.
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item
+     * @param defaultValue a default value to emit if the source Observable
+     *                     emits no item
+     * @return an Observable that emits the single item emitted by the source
+     *         Observable, or default value if the source Observable is empty
+     * @throws IllegalArgumentException if the source emits more than one item
      */
     public Observable singleOrDefault(T defaultValue) {
         return create(OperationSingle. singleOrDefault(this, defaultValue));
@@ -5298,21 +5347,22 @@ public Observable singleOrDefault(T defaultValue) {
 
     /**
      * If the Observable completes after emitting a single item that matches a
-     * predicate, return an Observable containing that item. If it emits no such
-     * item, return an Observable containing the defaultValue. If it emits more
-     * than one such item, throw an IllegalArgumentException.
-     * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no
-     *            matching items
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the
-     *            Observable
-     * @return an Observable containing the single item emitted by the source
-     *         Observable that matches the predicate, or an Observable
-     *         containing the defaultValue if no item matches the predicate
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item matching the predicate
+     * predicate, return an Observable that emits that item. If the source
+     * Observable emits no such item, return an Observable that emits a default
+     * item. If the source Observable emits more than one such item, throw an
+     * IllegalArgumentException.
+     * 
    
+     * 
+     * 
+     * @param defaultValue a default value to emit if the source Observable
+     *                     emits no matching items
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  source Observable
+     * @return an Observable that emits the single item emitted by the source
+     *         Observable that matches the predicate, or the default item if no
+     *         emitted item matches the predicate
+     * @throws IllegalArgumentException if the source emits more than one item
+     *                                  matching the predicate
      */
     public Observable singleOrDefault(T defaultValue, Func1 predicate) {
         return filter(predicate).singleOrDefault(defaultValue);
@@ -5320,8 +5370,8 @@ public Observable singleOrDefault(T defaultValue, Func1 p
 
     /**
      * Returns an Observable that emits only the very first item emitted by the
-     * source Observable, or an IllegalArgumentException if the source
-     * {@link Observable} is empty.
+     * source Observable, or an IllegalArgumentException if the
+     * source {@link Observable} is empty.
      * 
    
      * 
      * 
@@ -5335,8 +5385,8 @@ public Observable first() {
 
     /**
      * Returns an Observable that emits only the very first item emitted by the
-     * source Observable that satisfies a given condition, or an IllegalArgumentException
-     * if no such items are emitted.
+     * source Observable that satisfies a given condition, or an
+     * IllegalArgumentException if no such items are emitted.
      * 
    
      * 
      * 
@@ -5467,11 +5517,11 @@ public Observable takeWhileWithIndex(final Func2
-     * 
+     * 
      * 
      * @return an Observable that emits only the very first item from the
-     *         source, or an empty Observable if the source Observable completes without
-     *         emitting a single item
+     *         source, or an empty Observable if the source Observable completes
+     *         without emitting a single item
      * @deprecated Use take(1) directly.
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.First
@@ -5485,12 +5535,13 @@ public Observable takeFirst() {
      * 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 an empty Observable if the source Observable
-     *         completes without emitting a single matching item
+     *         given condition from the source, or an empty Observable if the
+     *         source Observable completes without emitting a single matching
+     *         item
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.First
      */
@@ -5502,7 +5553,7 @@ public Observable takeFirst(Func1 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
@@ -5515,66 +5566,78 @@ public Observable takeLast(final int count) {
     }
 
     /**
-     * Return an Observable which contains the items from this observable which
-     * were emitted not before this completed minus a time window.
+     * Return an Observable which emits the items from the source Observable
+     * that were emitted not before it completed minus a time window.
+     * 
    
+     * 
      * 
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @return an Observable which contains the items from this observable which
-     *         were emitted not before this completed minus a time window.
+     * @return an Observable that emits the items from the source Observable
+     *         that were emitted not before it completed minus a time window
      */
     public Observable takeLast(long time, TimeUnit unit) {
         return takeLast(time, unit, Schedulers.threadPoolForComputation());
     }
     
     /**
-     * Return an Observable which contains the items from this observable which
-     * were emitted not before this completed minus a time window, where the timing
-     * information is provided by the given scheduler.
+     * Return an Observable that emits the items from the source Observable that
+     * were emitted not before the source Observable completed minus a time
+     * window, where the timing information is provided by the given scheduler.
+     * 
    
+     * 
      * 
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @param scheduler the scheduler which provides the timestamps for the observed
-     *                  elements
-     * @return an Observable which contains the items from this observable which
-     *         were emitted not before this completed minus a time window, where the timing
-     * information is provided by the given scheduler
+     * @param scheduler the Scheduler that provides the timestamps for the
+     *                  Observed items
+     * @return an Observable that emits the items from the source Observable
+     *         that were emitted not before it completed minus a time window,
+     *         where the timing information is provided by the given Scheduler
      */
     public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
     }
     
     /**
-     * Return an Observable which contains at most count items from this Observable
-     * which were emitted not before this completed minus a time window.
+     * Return an Observable that emits at most a specified number of items from
+     * the source Observable that were emitted not before it completed minus a
+     * time window.
+     * 
    
+     * 
      * 
-     * @param count the maximum number of items to return
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * @param count the maximum number of items to emit
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @return Return an Observable which contains at most count items from this Observable
-     *         which were emitted not before this completed minus a time window.
+     * @return an Observable that emits at most {@code count} items from the
+     *         source Observable which were emitted not before it completed
+     *         minus a time window
      */
     public Observable takeLast(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Return an Observable which contains at most count items from this Observable
-     * which were emitted not before this completed minus a time window, where the timing
-     * information is provided by the given scheduler.
+     * Return an Observable that emits at most a specified number of items from
+     * the source Observable that were emitted not before it completed minus a
+     * time window, where the timing information is provided by a given
+     * scheduler.
+     * 
    
+     * 
      * 
-     * @param count the maximum number of items to return
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * @param count the maximum number of items to emit
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @param scheduler the scheduler which provides the timestamps for the observed
-     *                  elements
-     * @return Return an Observable which contains at most count items from this Observable
-     *         which were emitted not before this completed minus a time window, where the timing
-     *         information is provided by the given scheduler
+     * @param scheduler the Scheduler that provides the timestamps for the
+     *                  observed items
+     * @return an Observable that emits at most {@code count} items from the
+     *         source Observable which were emitted not before it completed
+     *         minus a time window, where the timing information is provided by
+     *         the given {@code scheduler}
      */
     public Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
         if (count < 0) {
@@ -5584,72 +5647,93 @@ public Observable takeLast(int count, long time, TimeUnit unit, Scheduler sch
     }
 
     /**
-     * Return an Observable which emits single List containing the last count 
-     * elements from this Observable.
+     * Return an Observable that emits single List containing the last
+     * {@code count} elements emitted by the source Observable.
+     * 
    
+     * 
      * 
      * @param count the number of items to take last
-     * @return an Observable which emits single list containing  the last count 
-     *         elements from this Observable.
+     * @return an Observable that emits a single list containing the last
+     *         {@code count} elements emitted by the source Observable
      */
     public Observable> takeLastBuffer(int count) {
         return takeLast(count).toList();
     }
     
     /**
-     * Return an Observable which emits single List containing items which
-     * were emitted not before this completed minus a time window.
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * Return an Observable that emits single List containing items that were
+     * emitted by the source Observable not before it completed minus a time
+     * window.
+     * 
    
+     * 
+     *
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @return an Observable which emits single list containing items which
-     *         were emitted not before this completed minus a time window
+     * @return an Observable that emits single list containing items that were
+     *         were emitted by the source Observable not before it completed
+     *         minus a time window
      */
     public Observable> takeLastBuffer(long time, TimeUnit unit) {
         return takeLast(time, unit).toList();
     }
 
     /**
-     * Return an Observable which emits single List containing items which 
-     * were emitted not before this completed minus a time window, where the timing
-     * information is provided by the given scheduler.
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * Return an Observable that emits single List containing items that were
+     * emitted by the source Observable not before it completed minus a time
+     * window, where the timing information is provided by the given Scheduler.
+     * 
    
+     * 
+     *
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @param scheduler the scheduler which provides the timestamps for the observed
-     *                  elements
-     * @return an Observable which emits single list containing items which 
-     *         were emitted not before this completed minus a time window, where the timing
-     *         information is provided by the given scheduler
+     * @param scheduler the Scheduler that provides the timestamps for the
+     *                  observed items
+     * @return an Observable that emits single list containing items that were
+     *         were emitted by the source Observable not before it completed
+     *         minus a time window, where the timing information is provided by
+     *         the given scheduler
      */
     public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(time, unit, scheduler).toList();
     }
 
     /**
-     * Return an Observable which emits a single List containing at most count items 
-     * from this Observable which were emitted not before this completed minus a time window.
-     * @param count the number of items to take last
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * Return an Observable that emits a single List containing at most
+     * {@code count} items from the source Observable that were emitted not
+     * before it completed minus a time window.
+     * 
    
+     * 
+     *
+     * @param count the maximum number of items to emit
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @return an Observable which emits a single List containing at most count items 
-     *         from this Observable which were emitted not before this completed minus a time window.
+     * @return an Observable that emits a single List containing at most
+     *         {@code count} items emitted by the source Observable not before
+     *         it completed minus a time window
      */
     public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit).toList();
     }
 
     /**
-     * Return an Observable which emits a single List containing at most count items 
-     * from this Observable which were emitted not before this completed minus a time window.
-     * @param count the number of items to take last
-     * @param time the length of the time window, relative to the completion of this
-     *             observable.
+     * Return an Observable that emits a single List containing at most
+     * {@code count} items from the source Observable that were emitted not
+     * before it completed minus a time window.
+     * 
    
+     * 
+     *
+     * @param count the maximum number of items to emit
+     * @param time the length of the time window, relative to the completion of
+     *             the source Observable
      * @param unit the time unit
-     * @param scheduler the scheduler which provides the timestamps for the observed
-     *                  elements
-     * @return an Observable which emits a single List containing at most count items 
-     *         from this Observable which were emitted not before this completed minus a time window.
+     * @param scheduler the scheduler that provides the timestamps for the
+     *                  observed items
+     * @return an Observable that emits a single List containing at most
+     *         {@code count} items emitted by the source Observable not before
+     *         it completed minus a time window
      */
     public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(count, time, unit, scheduler).toList();
@@ -6112,14 +6196,14 @@ public Observable last() {
      * Returns an Observable that emits only the last item emitted by the source
      * Observable that satisfies a given condition, or an
      * IllegalArgumentException if no such items are emitted.
+     * 
    
+     * 
      * 
-     * @param predicate
-     *            the condition any source emitted item has to satisfy
+     * @param predicate the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item satisfying the given
      *         condition from the source, or an IllegalArgumentException if no
-     *         such items are emitted.
-     * @throws IllegalArgumentException
-     *             if no such itmes are emmited
+     *         such items are emitted
+     * @throws IllegalArgumentException if no such itmes are emmited
      */
     public Observable last(Func1 predicate) {
         return filter(predicate).takeLast(1).single();
@@ -6128,9 +6212,11 @@ public Observable last(Func1 predicate) {
     /**
      * Returns an Observable that emits only the last item emitted by the source
      * Observable, or a default item if the source is empty.
+     * 
    
+     * 
      * 
-     * @param defaultValue
-     *            the default item to emit if the source Observable is empty
+     * @param defaultValue the default item to emit if the source Observable is
+     *                     empty
      * @return an Observable that emits only the last item from the source, or a
      *         default item if the source is empty
      */
@@ -6141,12 +6227,13 @@ public Observable lastOrDefault(T defaultValue) {
     /**
      * Returns an Observable that emits only the last item emitted by the source
      * Observable that satisfies a given condition, or a default item otherwise.
+     * 
    
+     * 
      * 
-     * @param defaultValue
-     *            the default item to emit if the source Observable doesn't emit
-     *            anything that satisfies the given condition
-     * @param predicate
-     *            the condition any source emitted item has to satisfy
+     * @param defaultValue the default item to emit if the source Observable
+     *                     doesn't emit anything that satisfies the given
+     *                     condition
+     * @param predicate the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item from the source that
      *         satisfies the given condition, or a default item otherwise
      */
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 6e9dce1d35..1fd1c8a861 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -27,7 +27,7 @@
  * Subject that publishes only the last event to each {@link Observer} that has subscribed when the
  * sequence completes.
  * 
    
- * 
+ * 
  * 
    
  * Example usage:
  * 
    
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 21f6252295..18d0e9f973 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -26,7 +26,7 @@
 /**
  * Subject that publishes the most recent and all subsequent events to each subscribed {@link Observer}.
  * 
    
- * 
+ * 
  * 
    
  * Example usage:
  * 
    
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index daa9dd6636..bec3a10fa3 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -26,7 +26,7 @@
 /**
  * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
  * 
    
- * 
+ * 
  * 
    
  * Example usage:
  * 
    

From 4377b364dcb7368a6d2b0dd4a5eeef48733e8983 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 21:06:25 -0800
Subject: [PATCH 132/441] Fix TakeLast after removing
 SingleAssignmentSubscription

- SingleAssignmentSubscription was removed in one merge, TakeLast modified in another merge.
---
 .../src/main/java/rx/operators/OperationTakeLast.java     | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index c0558d43e1..bdea8a0a25 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -25,7 +25,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.subscriptions.SingleAssignmentSubscription;
+import rx.subscriptions.BooleanSubscription;
 import rx.util.Timestamped;
 
 /**
@@ -156,9 +156,9 @@ public TakeLastTimed(Observable source, int count, long time, TimeU
 
         @Override
         public Subscription onSubscribe(Observer t1) {
-            SingleAssignmentSubscription sas = new SingleAssignmentSubscription();
-            sas.set(source.subscribe(new TakeLastTimedObserver(t1, sas, count, ageMillis, scheduler)));
-            return sas;
+            SafeObservableSubscription s = new SafeObservableSubscription();
+            source.subscribe(new TakeLastTimedObserver(t1, s, count, ageMillis, scheduler));
+            return s;
         }
     }
     /** Observes source values and keeps the most recent items. */

From 1b3feeb9c5eb7d780e3aba2da19f779bca2cf7c9 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 21:07:27 -0800
Subject: [PATCH 133/441] Update Tests for doOn* Changes

---
 rxjava-core/src/test/java/rx/ObservableDoOnTest.java          | 2 +-
 .../src/test/java/rx/operators/OperationDoOnEachTest.java     | 2 +-
 .../src/test/java/rx/operators/OperationObserveOnTest.java    | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
index 03aa8f53a4..2a4dc0ccd6 100644
--- a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
+++ b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
@@ -30,7 +30,7 @@ public class ObservableDoOnTest {
     @Test
     public void testDoOnEach() {
         final AtomicReference r = new AtomicReference();
-        String output = Observable.from("one").doOnEach(new Action1() {
+        String output = Observable.from("one").doOnNext(new Action1() {
 
             @Override
             public void call(String v) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
index e1e72a249a..a902312ba1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
@@ -108,7 +108,7 @@ public String call(String s) {
     @Test
     public void testDoOnEachWithErrorInCallback() {
         Observable base     = Observable.from("one", "two", "fail", "three");
-        Observable doOnEach = base.doOnEach(new Action1() {
+        Observable doOnEach = base.doOnNext(new Action1() {
             @Override
             public void call(String s) {
                 if ("fail".equals(s)) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
index 554b583247..626d6409d7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
@@ -98,7 +98,7 @@ public void testThreadName() throws InterruptedException {
         final CountDownLatch completedLatch = new CountDownLatch(1);
 
         // assert subscribe is on main thread
-        obs = obs.doOnEach(new Action1() {
+        obs = obs.doOnNext(new Action1() {
 
             @Override
             public void call(String s) {
@@ -110,7 +110,7 @@ public void call(String s) {
         });
 
         // assert observe is on new thread
-        obs.observeOn(Schedulers.newThread()).doOnEach(new Action1() {
+        obs.observeOn(Schedulers.newThread()).doOnNext(new Action1() {
 
             @Override
             public void call(String t1) {

From b378593b475b19c050383c3c857c4e37fa5740e5 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 21:09:50 -0800
Subject: [PATCH 134/441] MergeMap, ConcatMap, SwitchMap
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- flattening map implementations that better fit mental models and use cases
- keeping flatMap as alias to mergeMap since flatMap is common … (though flatMap still confuses people)
- deprecate mapMany as alias to flatMap and mergeMap
---
 rxjava-core/src/main/java/rx/Observable.java  | 64 ++++++++++++++++++-
 .../main/java/rx/operators/OperationMap.java  | 20 ------
 .../java/rx/operators/OperationMapTest.java   |  8 +--
 3 files changed, 65 insertions(+), 27 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index b6a0e18c1d..f843d63947 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3653,7 +3653,7 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      * @see RxJava Wiki: zip()
      */
     public static  Observable zip(Observable> ws, final FuncN zipFunction) {
-        return ws.toList().mapMany(new Func1>, Observable>() {
+        return ws.toList().mergeMap(new Func1>, Observable>() {
             @Override
             public Observable call(List> wsList) {
                 return create(OperationZip.zip(wsList, zipFunction));
@@ -3891,7 +3891,64 @@ public Observable finallyDo(Action0 action) {
      * @see #mapMany(Func1)
      */
     public  Observable flatMap(Func1> func) {
-        return mapMany(func);
+        return mergeMap(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: {@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 RxJava Wiki: flatMap()
+     * @see #flatMap(Func1)
+     */
+    public  Observable mergeMap(Func1> func) {
+        return merge(map(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 concatting those resulting Observables and emitting the
+     * results of this concat.
+     * 
    
+     * 
+     * @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 concatting the results of the Observables obtained
+     *         from this transformation.
+     */
+    public  Observable concatMap(Func1> func) {
+        return concat(map(func));
+    }
+    
+    /**
+     * Creates a new Observable by applying a function that you supply to each
+     * item emitted by the source Observable resulting in an Observable of Observables.
+     * 
    
+     * Then a {@link #switchLatest(Observable)} / {@link #switchOnNext(Observable)} is applied.
+     * 
+     * @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 then switch
+     */
+    public  Observable switchMap(Func1> func) {
+        return switchOnNext(map(func));
     }
 
     /**
@@ -3965,9 +4022,10 @@ public  Observable mapWithIndex(Func2 fun
      *         from this transformation.
      * @see RxJava Wiki: mapMany()
      * @see #flatMap(Func1)
+     * @deprecated
      */
     public  Observable mapMany(Func1> func) {
-        return create(OperationMap.mapMany(this, func));
+        return mergeMap(func);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMap.java b/rxjava-core/src/main/java/rx/operators/OperationMap.java
index d78b5dc6ef..4277edfd1d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMap.java
@@ -77,26 +77,6 @@ public Subscription onSubscribe(Observer observer) {
         };
     }
 
-    /**
-     * Accepts a sequence of observable sequences and a transformation function. Returns a flattened sequence that is the result of
-     * applying the transformation function to each item in the sequence of each observable sequence.
-     * 
    
-     * The closure should return an Observable which will then be merged.
-     * 
-     * @param sequence
-     *            the input sequence.
-     * @param func
-     *            a function to apply to each item in the sequence.
-     * @param 
-     *            the type of the input sequence.
-     * @param 
-     *            the type of the output sequence.
-     * @return a sequence that is the result of applying the transformation function to each item in the input sequence.
-     */
-    public static  OnSubscribeFunc mapMany(Observable sequence, Func1> func) {
-        return OperationMerge.merge(Observable.create(map(sequence, func)));
-    }
-
     /**
      * An observable sequence that is the result of applying a transformation to each item in an input sequence.
      * 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
index 463b2dca7a..6f77433623 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
@@ -118,7 +118,7 @@ public void testMapMany() {
         Observable ids = Observable.from(1, 2);
 
         /* now simulate the behavior to take those IDs and perform nested async calls based on them */
-        Observable m = Observable.create(mapMany(ids, new Func1>() {
+        Observable m = ids.flatMap(new Func1>() {
 
             @Override
             public Observable call(Integer id) {
@@ -143,7 +143,7 @@ public String call(Map map) {
                 }));
             }
 
-        }));
+        });
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -166,7 +166,7 @@ public void testMapMany2() {
 
         Observable>> observable = Observable.from(observable1, observable2);
 
-        Observable m = Observable.create(mapMany(observable, new Func1>, Observable>() {
+        Observable m = observable.flatMap(new Func1>, Observable>() {
 
             @Override
             public Observable call(Observable> o) {
@@ -179,7 +179,7 @@ public String call(Map map) {
                 }));
             }
 
-        }));
+        });
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));

From c300559c8a0bc0c7855c0fb86212c3e8343c0f8f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 21:11:03 -0800
Subject: [PATCH 135/441] Deprecate manWithIndex
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If we leave mapWithIndex then we should have “withIndex” on many other operators. Instead of this, an Observable should just be zipped with an infinite stream of numbers and the zip function provides the index.
This keeps the API surface area smaller and provides the desired behavior on all operators.
---
 rxjava-core/src/main/java/rx/Observable.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f843d63947..2cc18338b6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3999,6 +3999,7 @@ public  Observable map(Func1 func) {
      *         transformed by the given function
      * @see RxJava Wiki: mapWithIndex()
      * @see MSDN: Observable.Select
+     * @deprecate just use zip with {@link Observable#range(int)}
      */
     public  Observable mapWithIndex(Func2 func) {
         return create(OperationMap.mapWithIndex(this, func));

From 985005e89dc783c99aca7a2582986000d899a07d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 21:11:39 -0800
Subject: [PATCH 136/441] Deprecate aggregate in favor of reduce

We have had aggregate from Rx.Net for a while but long ago migrated to reduce as the primary. Time to deprecate it.
---
 rxjava-core/src/main/java/rx/Observable.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2cc18338b6..744265416a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5139,6 +5139,7 @@ public ConnectableObservable publishLast() {
      *
      * @see RxJava Wiki: aggregate()
      * @see #reduce(Func2)
+     * @deprecated
      */
     public Observable aggregate(Func2 accumulator) {
         return reduce(accumulator);
@@ -5181,6 +5182,7 @@ public  Observable reduce(R initialValue, Func2 accumulat
      * 
      * @see RxJava Wiki: aggregate()
      * @see #reduce(Object, Func2)
+     * @deprecated
      */
     public  Observable aggregate(R initialValue, Func2 accumulator) {
         return reduce(initialValue, accumulator);

From f6676429980073f83be79d9e8731bd971ca39bb5 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 23 Dec 2013 22:55:56 -0800
Subject: [PATCH 137/441] Fix SafeObserver handling of onComplete errors

Fixes https://github.com/Netflix/RxJava/issues/630
---
 .../main/java/rx/operators/SafeObserver.java  |  82 +++++---
 .../java/rx/operators/SafeObserverTest.java   | 197 ++++++++++++++++++
 2 files changed, 247 insertions(+), 32 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/operators/SafeObserverTest.java

diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 3e6508dac9..4768fb8653 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -19,7 +19,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observer;
+import rx.Subscription;
 import rx.plugins.RxJavaPlugins;
+import rx.subscriptions.Subscriptions;
 import rx.util.CompositeException;
 import rx.util.OnErrorNotImplementedException;
 
@@ -59,7 +61,12 @@ public class SafeObserver implements Observer {
 
     private final Observer actual;
     private final AtomicBoolean isFinished = new AtomicBoolean(false);
-    private final SafeObservableSubscription subscription;
+    private final Subscription subscription;
+
+    public SafeObserver(Observer actual) {
+        this.subscription = Subscriptions.empty();
+        this.actual = actual;
+    }
 
     public SafeObserver(SafeObservableSubscription subscription, Observer actual) {
         this.subscription = subscription;
@@ -73,44 +80,18 @@ public void onCompleted() {
                 actual.onCompleted();
             } catch (Throwable e) {
                 // handle errors if the onCompleted implementation fails, not just if the Observable fails
-                onError(e);
+                _onError(e);
+            } finally {
+                // auto-unsubscribe
+                subscription.unsubscribe();
             }
-            // auto-unsubscribe
-            subscription.unsubscribe();
         }
     }
 
     @Override
     public void onError(Throwable e) {
         if (isFinished.compareAndSet(false, true)) {
-            try {
-                actual.onError(e);
-            } catch (Throwable e2) {
-                if (e2 instanceof OnErrorNotImplementedException) {
-                    /**
-                     * onError isn't implemented so throw
-                     * 
-                     * https://github.com/Netflix/RxJava/issues/198
-                     * 
-                     * Rx Design Guidelines 5.2
-                     * 
-                     * "when calling the Subscribe method that only has an onNext argument, the OnError behavior will be
-                     * to rethrow the exception on the thread that the message comes out from the observable sequence.
-                     * The OnCompleted behavior in this case is to do nothing."
-                     */
-                    throw (OnErrorNotImplementedException) e2;
-                } else {
-                    // if the onError itself fails then pass to the plugin
-                    // see https://github.com/Netflix/RxJava/issues/216 for further discussion
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
-                    // and throw exception despite that not being proper for Rx
-                    // https://github.com/Netflix/RxJava/issues/198
-                    throw new RuntimeException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
-                }
-            }
-            // auto-unsubscribe
-            subscription.unsubscribe();
+            _onError(e);
         }
     }
 
@@ -126,4 +107,41 @@ public void onNext(T args) {
         }
     }
 
+    /*
+     * The logic for `onError` without the `isFinished` check so it can be called from within `onCompleted`.
+     * 
+     * See https://github.com/Netflix/RxJava/issues/630 for the report of this bug.
+     */
+    protected void _onError(Throwable e) {
+        try {
+            actual.onError(e);
+        } catch (Throwable e2) {
+            if (e2 instanceof OnErrorNotImplementedException) {
+                /**
+                 * onError isn't implemented so throw
+                 * 
+                 * https://github.com/Netflix/RxJava/issues/198
+                 * 
+                 * Rx Design Guidelines 5.2
+                 * 
+                 * "when calling the Subscribe method that only has an onNext argument, the OnError behavior will be
+                 * to rethrow the exception on the thread that the message comes out from the observable sequence.
+                 * The OnCompleted behavior in this case is to do nothing."
+                 */
+                throw (OnErrorNotImplementedException) e2;
+            } else {
+                // if the onError itself fails then pass to the plugin
+                // see https://github.com/Netflix/RxJava/issues/216 for further discussion
+                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
+                // and throw exception despite that not being proper for Rx
+                // https://github.com/Netflix/RxJava/issues/198
+                throw new RuntimeException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
+            }
+        } finally {
+            // auto-unsubscribe
+            subscription.unsubscribe();
+        }
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java b/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java
new file mode 100644
index 0000000000..d59a6db6b3
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java
@@ -0,0 +1,197 @@
+/**
+ * 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 static org.junit.Assert.*;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observer;
+
+public class SafeObserverTest {
+
+    @Test
+    public void onNextFailure() {
+        AtomicReference onError = new AtomicReference();
+        try {
+            OBSERVER_ONNEXT_FAIL(onError).onNext("one");
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected
+            assertNull(onError.get());
+        }
+    }
+
+    @Test
+    public void onNextFailureSafe() {
+        AtomicReference onError = new AtomicReference();
+        try {
+            new SafeObserver(OBSERVER_ONNEXT_FAIL(onError)).onNext("one");
+            assertNotNull(onError.get());
+        } catch (Exception e) {
+            fail("expects exception to be passed to onError");
+        }
+    }
+
+    @Test
+    public void onCompletedFailure() {
+        AtomicReference onError = new AtomicReference();
+        try {
+            OBSERVER_ONCOMPLETED_FAIL(onError).onCompleted();
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected
+            assertNull(onError.get());
+        }
+    }
+
+    @Test
+    public void onCompletedFailureSafe() {
+        AtomicReference onError = new AtomicReference();
+        try {
+            new SafeObserver(OBSERVER_ONCOMPLETED_FAIL(onError)).onCompleted();
+            assertNotNull(onError.get());
+        } catch (Exception e) {
+            fail("expects exception to be passed to onError");
+        }
+    }
+
+    @Test
+    public void onErrorFailure() {
+        try {
+            OBSERVER_ONERROR_FAIL().onError(new RuntimeException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void onErrorFailureSafe() {
+        try {
+            new SafeObserver(OBSERVER_ONERROR_FAIL()).onError(new RuntimeException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected since onError fails so SafeObserver can't help
+        }
+    }
+
+    @Test
+    public void onNextOnErrorFailure() {
+        try {
+            OBSERVER_ONNEXT_ONERROR_FAIL().onError(new RuntimeException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void onNextOnErrorFailureSafe() {
+        try {
+            new SafeObserver(OBSERVER_ONNEXT_ONERROR_FAIL()).onError(new RuntimeException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            // expected since onError fails so SafeObserver can't help
+        }
+    }
+
+    private static Observer OBSERVER_ONNEXT_FAIL(final AtomicReference onError) {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                onError.set(e);
+            }
+
+            @Override
+            public void onNext(String args) {
+                throw new RuntimeException("onNextFail");
+            }
+        };
+
+    }
+
+    private static Observer OBSERVER_ONNEXT_ONERROR_FAIL() {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new RuntimeException("onErrortFail");
+            }
+
+            @Override
+            public void onNext(String args) {
+                throw new RuntimeException("onNextFail");
+            }
+
+        };
+    }
+
+    private static Observer OBSERVER_ONERROR_FAIL() {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new RuntimeException("onErrorFail");
+            }
+
+            @Override
+            public void onNext(String args) {
+
+            }
+
+        };
+    }
+
+    private static Observer OBSERVER_ONCOMPLETED_FAIL(final AtomicReference onError) {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+                throw new RuntimeException("onCompletedFail");
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                onError.set(e);
+            }
+
+            @Override
+            public void onNext(String args) {
+
+            }
+
+        };
+    }
+}

From 8cfb25b6a01ec5df665443018a72eef14bed7434 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Tue, 24 Dec 2013 16:26:44 +0100
Subject: [PATCH 138/441] Removed ObserverBase

---
 .../src/main/java/rx/joins/JoinObserver1.java | 62 ++++++++++------
 .../src/main/java/rx/joins/ObserverBase.java  | 72 -------------------
 2 files changed, 41 insertions(+), 93 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/joins/ObserverBase.java

diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index ede55f0584..b191641352 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -23,28 +23,31 @@
 
 import rx.Notification;
 import rx.Observable;
+import rx.Observer;
 import rx.operators.SafeObservableSubscription;
+import rx.operators.SafeObserver;
 import rx.util.functions.Action1;
 
 /**
  * Default implementation of a join observer.
  */
-public final class JoinObserver1 extends ObserverBase> implements JoinObserver {
+public final class JoinObserver1 implements Observer>, JoinObserver {
     private Object gate;
     private final Observable source;
     private final Action1 onError;
     private final List activePlans;
     private final Queue> queue;
-    private final SafeObservableSubscription subscription;
+    private final SafeObservableSubscription subscription = new SafeObservableSubscription();
     private volatile boolean done;
     private final AtomicBoolean subscribed = new AtomicBoolean(false);
+    private final SafeObserver> safeObserver;
     
     public JoinObserver1(Observable source, Action1 onError) {
         this.source = source;
         this.onError = onError;
         queue = new LinkedList>();
-        subscription = new SafeObservableSubscription();
         activePlans = new ArrayList();
+        safeObserver = new SafeObserver>(subscription, new InnerObserver());
     }
     public Queue> queue() {
         return queue;
@@ -67,35 +70,52 @@ public void dequeue() {
         queue.remove();
     }
 
-    @Override
-    protected void onNextCore(Notification args) {
-        synchronized (gate) {
-            if (!done) {
-                if (args.isOnError()) {
-                    onError.call(args.getThrowable());
-                    return;
-                }
-                queue.add(args);
-                
-                // remark: activePlans might change while iterating
-                for (ActivePlan0 a : new ArrayList(activePlans)) {
-                    a.match();
+    private final class InnerObserver implements Observer> {
+
+        @Override
+        public void onNext(Notification args) {
+            synchronized (gate) {
+                if (!done) {
+                    if (args.isOnError()) {
+                        onError.call(args.getThrowable());
+                        return;
+                    }
+                    queue.add(args);
+
+                    // remark: activePlans might change while iterating
+                    for (ActivePlan0 a : new ArrayList(activePlans)) {
+                        a.match();
+                    }
                 }
             }
         }
+
+        @Override
+        public void onError(Throwable e) {
+            // not expected
+        }
+
+        @Override
+        public void onCompleted() {
+            // not expected or ignored
+        }
+    }
+    
+    @Override
+    public void onNext(Notification args) {
+        safeObserver.onNext(args);
     }
 
     @Override
-    protected void onErrorCore(Throwable e) {
-        // not expected
+    public void onError(Throwable e) {
+        safeObserver.onError(e);
     }
 
     @Override
-    protected void onCompletedCore() {
-        // not expected or ignored
+    public void onCompleted() {
+        safeObserver.onCompleted();
     }
     
-    
     void removeActivePlan(ActivePlan0 activePlan) {
         activePlans.remove(activePlan);
         if (activePlans.isEmpty()) {
diff --git a/rxjava-core/src/main/java/rx/joins/ObserverBase.java b/rxjava-core/src/main/java/rx/joins/ObserverBase.java
deleted file mode 100644
index f1144a8ad2..0000000000
--- a/rxjava-core/src/main/java/rx/joins/ObserverBase.java
+++ /dev/null
@@ -1,72 +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.joins;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import rx.Observer;
-
-/**
- * Implements an observer that ensures proper event delivery
- * semantics to its abstract onXxxxCore methods.
- */
-public abstract class ObserverBase implements Observer {
-    private final AtomicBoolean completed = new AtomicBoolean();
-
-    @Override
-    public void onNext(T args) {
-        if (!completed.get()) {
-            onNextCore(args);
-        }
-    }
-
-    @Override
-    public void onError(Throwable e) {
-        if (completed.compareAndSet(false, true)) {
-            onErrorCore(e);
-        }
-    }
-
-    @Override
-    public void onCompleted() {
-        if (completed.compareAndSet(false, true)) {
-            onCompletedCore();
-        }
-    }
-    /**
-     * Implement this method to react to the receival of a new element in the sequence.
-     */
-    protected abstract void onNextCore(T args);
-    /**
-     * Implement this method to react to the occurrence of an exception.
-     */
-    protected abstract void onErrorCore(Throwable e);
-    /**
-     * Implement this method to react to the end of the sequence.
-     */
-    protected abstract void onCompletedCore();
-    /**
-     * Try to trigger the error state.
-     * @param t 
-     * @return false if already completed
-     */
-    protected boolean fail(Throwable t) {
-        if (completed.compareAndSet(false, true)) {
-            onErrorCore(t);
-            return true;
-        }
-        return false;
-    }
-}

From 622b66125a43aa77d790a6418f311714ac9f5955 Mon Sep 17 00:00:00 2001
From: headinthebox 
Date: Tue, 24 Dec 2013 10:31:13 -0800
Subject: [PATCH 139/441] Fixed Scala bindings

---
 language-adaptors/rxjava-scala/build.gradle   |  4 +-
 .../main/scala/rx/lang/scala/Observable.scala | 47 ++++++++++++++-----
 .../subscriptions/BooleanSubscription.scala   |  8 +++-
 .../MultiAssignmentSubscription.scala         |  4 +-
 .../subscriptions/SerialSubscription.scala    |  4 +-
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../rx/operators/OperationWindowTest.java     |  8 ++--
 7 files changed, 53 insertions(+), 26 deletions(-)

diff --git a/language-adaptors/rxjava-scala/build.gradle b/language-adaptors/rxjava-scala/build.gradle
index db194a6d28..8083feaf37 100644
--- a/language-adaptors/rxjava-scala/build.gradle
+++ b/language-adaptors/rxjava-scala/build.gradle
@@ -23,7 +23,7 @@ sourceSets {
             srcDir 'src/main/scala'
             srcDir 'src/test/scala'
             srcDir 'src/examples/scala'
-            srcDir 'src/examples/java'
+            //srcDir 'src/examples/java'
         }
         java.srcDirs = []
     }
@@ -34,7 +34,7 @@ sourceSets {
         // the scala source set:
         scala { 
             srcDir 'src/examples/scala'
-            srcDir 'src/examples/java'
+            //srcDir 'src/examples/java'
         }
         java.srcDirs = []
     }
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index 6db7d41e25..9be58009dd 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -1860,6 +1860,38 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.doOnEach(observer.asJavaObserver))
   }
 
+  /**
+   * Invokes an action when the source Observable calls onNext.
+   *
+   * @param onNext the action to invoke when the source Observable calls onNext
+   * @return the source Observable with the side-effecting behavior applied
+   */
+  def doOnNext(onNext: T => Unit): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.doOnNext(onNext))
+  }
+
+  /**
+   * Invokes an action if the source Observable calls onError.
+   *
+   * @param onError the action to invoke if the source Observable calls
+   *                onError
+   * @return the source Observable with the side-effecting behavior applied
+   */
+  def doOnError(onError: Throwable => Unit): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.doOnError(onError))
+  }
+
+  /**
+   * Invokes an action when the source Observable calls onCompleted.
+   *
+   * @param onCompleted the action to invoke when the source Observable calls
+   *                    onCompleted
+   * @return the source Observable with the side-effecting behavior applied
+   */
+  def doOnCompleted(onCompleted: () => Unit): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.doOnCompleted(onCompleted))
+  }
+
   /**
    * Returns an Observable that applies the given function to each item emitted by an
    * Observable.
@@ -1869,9 +1901,7 @@ trait Observable[+T]
    * @return an Observable with the side-effecting behavior applied.
    */
   def doOnEach(onNext: T => Unit): Observable[T] = {
-    toScalaObservable[T](asJavaObservable.doOnEach(
-      onNext
-    ))
+    toScalaObservable[T](asJavaObservable.doOnNext(onNext))
   }
 
   /**
@@ -1884,10 +1914,7 @@ trait Observable[+T]
    * @return an Observable with the side-effecting behavior applied.
    */
   def doOnEach(onNext: T => Unit, onError: Throwable => Unit): Observable[T] = {
-    toScalaObservable[T](asJavaObservable.doOnEach(
-      onNext,
-      onError
-    ))
+    toScalaObservable[T](asJavaObservable.doOnEach(Observer(onNext, onError, ()=>{})))
   }
 
   /**
@@ -1901,11 +1928,7 @@ trait Observable[+T]
    * @return an Observable with the side-effecting behavior applied.
    */
   def doOnEach(onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit): Observable[T] = {
-    toScalaObservable[T](asJavaObservable.doOnEach(
-      onNext,
-      onError,
-      onCompleted
-    ))
+    toScalaObservable[T](asJavaObservable.doOnEach(Observer(onNext, onError,onCompleted)))
   }
 }
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala
index d7e0431d27..5f07497ca3 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala
@@ -27,7 +27,11 @@ private [scala] object BooleanSubscription {
 private [scala] class BooleanSubscription private[scala] (boolean: rx.subscriptions.BooleanSubscription)
   extends Subscription {
 
-  override val asJavaSubscription: rx.subscriptions.BooleanSubscription = new rx.subscriptions.BooleanSubscription() {
+  override val asJavaSubscription: rx.subscriptions.BooleanSubscription = boolean
+}
+
+/*
+new rx.subscriptions.BooleanSubscription() {
     override def unsubscribe(): Unit = {
       if(unsubscribed.compareAndSet(false, true)) {
         if(!boolean.isUnsubscribed) { boolean.unsubscribe() }
@@ -35,4 +39,4 @@ private [scala] class BooleanSubscription private[scala] (boolean: rx.subscripti
     }
     override def isUnsubscribed(): Boolean = unsubscribed.get() || boolean.isUnsubscribed
   }
-}
+ */
\ No newline at end of file
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala
index 8fa87c3ff5..1cbb0f8d6d 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/MultiAssignmentSubscription.scala
@@ -47,7 +47,7 @@ class MultipleAssignmentSubscription private[scala] (override val asJavaSubscrip
   /**
    * Gets the underlying subscription.
    */
-  def subscription: Subscription = Subscription(asJavaSubscription.getSubscription)
+  def subscription: Subscription = Subscription(asJavaSubscription.get)
 
   /**
    * Gets the underlying subscription
@@ -55,7 +55,7 @@ class MultipleAssignmentSubscription private[scala] (override val asJavaSubscrip
    * @return the [[rx.lang.scala.subscriptions.MultipleAssignmentSubscription]] itself.
    */
   def subscription_=(that: Subscription): this.type = {
-    asJavaSubscription.setSubscription(that.asJavaSubscription)
+    asJavaSubscription.set(that.asJavaSubscription)
     this
   }
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala
index d845b7e5cd..77b52e3b5f 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/SerialSubscription.scala
@@ -41,10 +41,10 @@ class SerialSubscription private[scala] (override val asJavaSubscription: rx.sub
   override def isUnsubscribed: Boolean = asJavaSubscription.isUnsubscribed
 
   def subscription_=(value: Subscription): this.type = {
-      asJavaSubscription.setSubscription(value.asJavaSubscription)
+      asJavaSubscription.set(value.asJavaSubscription)
       this
   }
-  def subscription: Subscription = Subscription(asJavaSubscription.getSubscription)
+  def subscription: Subscription = Subscription(asJavaSubscription.get)
 
 }
 
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 6f3f51f12d..4ce54dedf6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6793,7 +6793,7 @@ public void onNext(T args) { }
      * @see RxJava Wiki: doOnNext()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnNext(final Action1 onNext) {
+    public Observable doOnNext(final Action1 onNext) {
         Observer observer = new Observer() {
             @Override
             public void onCompleted() { }
@@ -6822,7 +6822,7 @@ public void onNext(T args) {
      * @see RxJava Wiki: doOnEach()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnEach(final Action1> onNotification) {
+    public Observable doOnEach(final Action1> onNotification) {
         Observer observer = new Observer() {
             @Override
             public void onCompleted() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index aeaa7d5103..ebe26dacba 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -50,10 +50,10 @@ private static  List> toLists(Observable> observables)
         final List> lists = new ArrayList>();
         Observable.concat(observables.map(new Func1, Observable>>() {
             @Override
-            public Observable> call(Observable xs) {
-                return xs.toList();
-            }
-        })).toBlockingObservable().forEach(new Action1>() {
+            public Observable> call(Observable xs) { return xs.toList(); }
+        }))
+                .toBlockingObservable()
+                .forEach(new Action1>() {
             @Override
             public void call(List xs) {
                 lists.add(xs);

From 866ddd34b160f850e06325014456fa2a2a14e2e7 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Tue, 24 Dec 2013 12:10:36 -0800
Subject: [PATCH 140/441] javadoc improvements: * diagrams for switchLatest,
 mergeMap, concatMap, switchMap, mapWithIndex, doOnNext * change text to note
 deprecation of aggregate * standardized formatting * force image size in
 ReplaySubject javadoc

---
 rxjava-core/src/main/java/rx/Observable.java  | 38 ++++++++++---------
 .../main/java/rx/subjects/ReplaySubject.java  |  2 +-
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4ce54dedf6..d8f7584a2c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1936,7 +1936,7 @@ public static  Observable switchOnNext(Observable
-     * 
+     * 
      * 
      * @param sequenceOfSequences the source Observable that emits Observables
      * @return an Observable that emits only the items emitted by the Observable
@@ -1976,7 +1976,8 @@ public static  Observable switchCase(Func0 caseSelector,
      *
      * @param  the case key type
      * @param  the result value type
-     * @param caseSelector the function that produces a case key when an Observer subscribes
+     * @param caseSelector the function that produces a case key when an
+     *                     Observer subscribes
      * @param mapOfCases a map that maps a case key to an Observable
      * @param scheduler the scheduler where the empty observable is observed
      * @return a particular Observable chosen by key from the map of
@@ -3945,9 +3946,7 @@ public  Observable flatMap(Func1
-     * 
-     * 
    
-     * 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
@@ -3965,9 +3964,10 @@ public  Observable mergeMap(Func1
+     * 
      * 
      * @param func a function that, when applied to an item emitted by the
      *             source Observable, returns an Observable
@@ -3982,9 +3982,11 @@ public  Observable concatMap(Func1
-     * Then a {@link #switchLatest(Observable)} / {@link #switchOnNext(Observable)} is applied.
+     * 
      * 
      * @param func a function that, when applied to an item emitted by the
      *             source Observable, returns an Observable
@@ -4035,7 +4037,7 @@ public  Observable map(Func1 func) {
      * emitted by an Observable and emits the results of these function
      * applications.
      * 
    
-     * 
+     * 
      * 
      * @param func a function to apply to each item emitted by the Observable
      *             that takes the index of the emitted item as additional
@@ -4044,7 +4046,7 @@ public  Observable map(Func1 func) {
      *         transformed by the given function
      * @see RxJava Wiki: mapWithIndex()
      * @see MSDN: Observable.Select
-     * @deprecate just use zip with {@link Observable#range(int)}
+     * @deprecated just use zip with {@link Observable#range(int)}
      */
     public  Observable mapWithIndex(Func2 func) {
         return create(OperationMap.mapWithIndex(this, func));
@@ -4285,8 +4287,8 @@ public Observable onErrorReturn(Func1 resumeFunction)
      * 
    
      * 
      * 
    
-     * This technique, which is called "reduce" or "aggregate" here, is
-     * sometimes called "fold," "accumulate," "compress," or "inject" in other
+     * This technique, which is called "reduce" here, is sometimes called
+     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
      * programming contexts. Groovy, for instance, has an inject
      * method that does a similar operation on lists.
      * 
@@ -5184,7 +5186,7 @@ public ConnectableObservable publishLast() {
      *
      * @see RxJava Wiki: aggregate()
      * @see #reduce(Func2)
-     * @deprecated
+     * @deprecated use #reduce(Func2)
      */
     public Observable aggregate(Func2 accumulator) {
         return reduce(accumulator);
@@ -5200,8 +5202,8 @@ public Observable aggregate(Func2 accumulator) {
      * 
    
      * 
      * 
    
-     * This technique, which is called "reduce" or "aggregate" here, is
-     * sometimes called "fold," "accumulate," "compress," or "inject" in other
+     * This technique, which is called "reduce" here, is sometimec called
+     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
      * programming contexts. Groovy, for instance, has an inject
      * method that does a similar operation on lists.
      * 
@@ -5227,7 +5229,7 @@ public  Observable reduce(R initialValue, Func2 accumulat
      * 
      * @see RxJava Wiki: aggregate()
      * @see #reduce(Object, Func2)
-     * @deprecated
+     * @deprecated use #reduce(Object, Func2)
      */
     public  Observable aggregate(R initialValue, Func2 accumulator) {
         return reduce(initialValue, accumulator);
@@ -6785,7 +6787,7 @@ public void onNext(T args) { }
      * Invokes an action when the source Observable calls
      * onNext.
      * 
    
-     * 
+     * 
      *
      * @param onCompleted the action to invoke when the source Observable calls
      *                    onCompleted
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 0546da9a0b..69ddb7470b 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -29,7 +29,7 @@
 /**
  * Subject that retains all events and will replay them to an {@link Observer} that subscribes.
  * 
    
- * 
+ * 
  * 
    
  * Example usage:
  * 
    

From a6c9bf900d53292db05531c741f152064b90fc4c Mon Sep 17 00:00:00 2001
From: MarioAriasC 
Date: Thu, 26 Dec 2013 14:38:32 +0000
Subject: [PATCH 141/441] Kotlin M6.2

---
 language-adaptors/rxjava-kotlin/build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-kotlin/build.gradle b/language-adaptors/rxjava-kotlin/build.gradle
index 9beef6d08c..aa44049d05 100644
--- a/language-adaptors/rxjava-kotlin/build.gradle
+++ b/language-adaptors/rxjava-kotlin/build.gradle
@@ -4,7 +4,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.6.800'
+        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.6.1673'
     }
 }
 
@@ -13,7 +13,7 @@ apply plugin: 'osgi'
 
 dependencies {
     compile project(':rxjava-core')
-    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.6.800'
+    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.6.1673'
     provided 'junit:junit-dep:4.10'
     provided 'org.mockito:mockito-core:1.8.5'
 }

From c530fe575d706163ec525fa0058524bbf8e82915 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 26 Dec 2013 11:30:17 -0800
Subject: [PATCH 142/441] Change in wiki page from "Mathematical Operators" to
 "Mathematical and Aggregate Operators" move toList, reduce, concat,
 toSortedList, toMap, and toMultiMap to that page deprecate aggregate in favor
 of reduce [should I move takeLast, last, and takeLastBuffer to the Aggregate
 operators page? they don't operate on the aggregate, exactly, but they do
 wait until the source completes before emitting anything]

---
 rxjava-core/src/main/java/rx/Observable.java | 80 ++++++++++----------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d8f7584a2c..44e4436ab4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1388,7 +1388,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     public static  Observable concat(Observable> observables) {
@@ -1406,7 +1406,7 @@ public static  Observable concat(ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1427,7 +1427,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1449,7 +1449,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1472,7 +1472,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1496,7 +1496,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1521,7 +1521,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1547,7 +1547,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -1574,7 +1574,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
+     * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat Method
      */
     @SuppressWarnings("unchecked")
@@ -4298,7 +4298,7 @@ public Observable onErrorReturn(Func1 resumeFunction)
      * @return an Observable that emits a single item that is the result of
      *         accumulating the output from the source Observable
      * @throws IllegalArgumentException if the source Observable emits no items
-     * @see RxJava Wiki: reduce()
+     * @see RxJava Wiki: reduce()
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
      */
@@ -4319,7 +4319,7 @@ public Observable reduce(Func2 accumulator) {
      * 
      * @return an Observable that emits the number of elements emitted by the
      *         source Observable as its single item
-     * @see RxJava Wiki: count()
+     * @see RxJava Wiki: count()
      * @see MSDN: Observable.Count
      * @see #longCount()
      */
@@ -4341,7 +4341,7 @@ public Integer call(Integer t1, T t2) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Integers emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: sum()
+     * @see RxJava Wiki: sum()
      * @see MSDN: Observable.Sum
      */
     public static Observable sum(Observable source) {
@@ -4357,7 +4357,7 @@ public static Observable sum(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Longs emitted by the
      *         source Observable as its single item
-     * @see RxJava Wiki: sumLongs()
+     * @see RxJava Wiki: sumLongs()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumLongs(Observable source) {
@@ -4373,7 +4373,7 @@ public static Observable sumLongs(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Floats emitted by the
      *         source Observable as its single item
-     * @see RxJava Wiki: sumFloats()
+     * @see RxJava Wiki: sumFloats()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumFloats(Observable source) {
@@ -4389,7 +4389,7 @@ public static Observable sumFloats(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Doubles emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: sumDoubles()
+     * @see RxJava Wiki: sumDoubles()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumDoubles(Observable source) {
@@ -4406,7 +4406,7 @@ public static Observable sumDoubles(Observable source) {
      * @return an Observable that emits the average of all the Integers emitted
      *         by the source Observable as its single item
      * @throws IllegalArgumentException if the source Observable emits no items
-     * @see RxJava Wiki: average()
+     * @see RxJava Wiki: average()
      * @see MSDN: Observable.Average
      */
     public static Observable average(Observable source) {
@@ -4422,7 +4422,7 @@ public static Observable average(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Longs emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: averageLongs()
+     * @see RxJava Wiki: averageLongs()
      * @see MSDN: Observable.Average
      */
     public static Observable averageLongs(Observable source) {
@@ -4438,7 +4438,7 @@ public static Observable averageLongs(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Floats emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: averageFloats()
+     * @see RxJava Wiki: averageFloats()
      * @see MSDN: Observable.Average
      */
     public static Observable averageFloats(Observable source) {
@@ -4454,7 +4454,7 @@ public static Observable averageFloats(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Doubles emitted
      *         by the source Observable as its single item
-     * @see RxJava Wiki: averageDoubles()
+     * @see RxJava Wiki: averageDoubles()
      * @see MSDN: Observable.Average
      */
     public static Observable averageDoubles(Observable source) {
@@ -4489,7 +4489,7 @@ public static > Observable min(Observable
      * @return an Observable that emits the minimum item according to the
      *         specified comparator
      * @throws IllegalArgumentException if the source is empty
-     * @see RxJava Wiki: min()
+     * @see RxJava Wiki: min()
      * @see MSDN: Observable.Min
      */
     public Observable min(Comparator comparator) {
@@ -4506,7 +4506,7 @@ public Observable min(Comparator comparator) {
      * @param selector the key selector function
      * @return an Observable that emits a List of the items from the source
      *         Observable that had the minimum key value
-     * @see RxJava Wiki: minBy()
+     * @see RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
     public > Observable> minBy(Func1 selector) {
@@ -4526,7 +4526,7 @@ public > Observable> minBy(Func1 s
      * @return an Observable that emits a List of the items emitted by the
      *         source Observable that had the minimum key value according to the
      *         specified comparator
-     * @see RxJava Wiki: minBy()
+     * @see RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
     public  Observable> minBy(Func1 selector, Comparator comparator) {
@@ -4543,7 +4543,7 @@ public  Observable> minBy(Func1 selector, Comparator
      * @param source an Observable to scan for the maximum emitted item
      * @return an Observable that emits this maximum item from the source
      * @throws IllegalArgumentException if the source is empty
-     * @see RxJava Wiki: max()
+     * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
     public static > Observable max(Observable source) {
@@ -4561,7 +4561,7 @@ public static > Observable max(Observable
      * @return an Observable that emits the maximum item emitted by the source
      *         Observable, according to the specified comparator
      * @throws IllegalArgumentException if the source is empty
-     * @see RxJava Wiki: max()
+     * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
     public Observable max(Comparator comparator) {
@@ -4578,7 +4578,7 @@ public Observable max(Comparator comparator) {
      * @param selector the key selector function
      * @return an Observable that emits a List of those items emitted by the
      *         source Observable that had the maximum key value
-     * @see RxJava Wiki: maxBy()
+     * @see RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
     public > Observable> maxBy(Func1 selector) {
@@ -4598,7 +4598,7 @@ public > Observable> maxBy(Func1 s
      * @return an Observable that emits a List of those items emitted by the
      *         source Observable that had the maximum key value according to the
      *         specified comparator
-     * @see RxJava Wiki: maxBy()
+     * @see RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
     public  Observable> maxBy(Func1 selector, Comparator comparator) {
@@ -5184,7 +5184,7 @@ public ConnectableObservable publishLast() {
      * 
    
      * 
      *
-     * @see RxJava Wiki: aggregate()
+     * @see RxJava Wiki: reduce()
      * @see #reduce(Func2)
      * @deprecated use #reduce(Func2)
      */
@@ -5214,7 +5214,7 @@ public Observable aggregate(Func2 accumulator) {
      * @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 RxJava Wiki: reduce()
+     * @see RxJava Wiki: reduce()
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
      */
@@ -5227,7 +5227,7 @@ public  Observable reduce(R initialValue, Func2 accumulat
      * 
    
      * 
      * 
-     * @see RxJava Wiki: aggregate()
+     * @see RxJava Wiki: reduce()
      * @see #reduce(Object, Func2)
      * @deprecated use #reduce(Object, Func2)
      */
@@ -5918,7 +5918,7 @@ public Observable skipLast(int count) {
      * 
      * @return an Observable that emits a single item: a List containing all of
      *         the items emitted by the source Observable.
-     * @see RxJava Wiki: toList()
+     * @see RxJava Wiki: toList()
      */
     public Observable> toList() {
         return create(OperationToObservableList.toObservableList(this));
@@ -5937,7 +5937,7 @@ public Observable> toList() {
      *                            all other items emitted by the Observable
      * @return an Observable that emits the items from the source Observable in
      *         sorted order
-     * @see RxJava Wiki: toSortedList()
+     * @see RxJava Wiki: toSortedList()
      */
     public Observable> toSortedList() {
         return create(OperationToObservableSortedList.toSortedList(this));
@@ -5954,7 +5954,7 @@ public Observable> toSortedList() {
      *                     indicates their sort order
      * @return an Observable that emits the items from the source Observable in
      *         sorted order
-     * @see RxJava Wiki: toSortedList()
+     * @see RxJava Wiki: toSortedList()
      */
     public Observable> toSortedList(Func2 sortFunction) {
         return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
@@ -6329,7 +6329,7 @@ public Observable lastOrDefault(T defaultValue, Func1 pre
      * 
      * @return an Observable that emits the number of items emitted by the
      *         source Observable as its single, 64-bit long item 
-     * @see RxJava Wiki: count()
+     * @see RxJava Wiki: count()
      * @see MSDN: Observable.LongCount
      * @see #count()
      */
@@ -7173,7 +7173,7 @@ public  Observable join(Observable<
      *                    items to be used as keys in the HashMap
      * @return an Observable that emits a single HashMap containing the mapped
      *         items from the source Observable
-     * @see RxJava Wiki: toMap()
+     * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
     public  Observable> toMap(Func1 keySelector) {
@@ -7195,7 +7195,7 @@ public  Observable> toMap(Func1 keySelector
      *                      items to be used as value in the HashMap
      * @return an Observable that emits a single HashMap containing the mapped
      *         items from the source Observable
-     * @see RxJava Wiki: toMap()
+     * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
     public  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
@@ -7216,7 +7216,7 @@ public  Observable> toMap(Func1 keySelec
      * @param mapFactory the function that returns an Map instance to be used
      * @return an Observable that emits a single Map containing the mapped
      *         items emitted by the source Observable
-     * @see RxJava Wiki: toMap()
+     * @see RxJava Wiki: toMap()
      */
     public  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
         return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
@@ -7233,7 +7233,7 @@ public  Observable> toMap(Func1 keySelec
      *                    items to be used as key in the HashMap
      * @return an Observable that emits a single HashMap containing an ArrayList
      *         of items mapped from the source Observable
-     * @see RxJava Wiki: toMultiMap()
+     * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
     public  Observable>> toMultimap(Func1 keySelector) {
@@ -7254,7 +7254,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMultiMap()
+     * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
     public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
@@ -7276,7 +7276,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMultiMap()
+     * @see RxJava Wiki: toMap()
      */
     public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory));
@@ -7299,7 +7299,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMultiMap()
+     * @see RxJava Wiki: toMap()
      */
     public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));

From 97f2b979dbf2ab278bb442233920461fb9348337 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 26 Dec 2013 16:01:26 -0800
Subject: [PATCH 143/441] javadoc improvements * add "see also" notes about
 hidden Rx.NET "asyncFoo" methods to Observable.java * reformat
 BlockingObservable javadoc comments to Oracle formatting standards * add
 links to RxJava Wiki & MSDN web pages as "see also" links in
 BlockingObservable javadocs

---
 rxjava-core/src/main/java/rx/Observable.java  |  91 +++---
 .../rx/observables/BlockingObservable.java    | 273 +++++++++++-------
 2 files changed, 218 insertions(+), 146 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 44e4436ab4..c0fe0822d8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -648,7 +648,7 @@ public static  Observable create(OnSubscribeFunc func) {
      *         immediately invokes the {@link Observer}'s
      *         {@link Observer#onCompleted() onCompleted} method
      * @see RxJava Wiki: empty()
-     * @see MSDN: Observable.Empty Method
+     * @see MSDN: Observable.Empty
      */
     public static  Observable empty() {
         return from(new ArrayList());
@@ -688,7 +688,7 @@ public static  Observable empty(Scheduler scheduler) {
      *         {@link Observer#onError onError} method when the Observer
      *         subscribes to it
      * @see RxJava Wiki: error()
-     * @see MSDN: Observable.Throw Method
+     * @see MSDN: Observable.Throw
      */
     public static  Observable error(Throwable exception) {
         return new ThrowObservable(exception);
@@ -708,7 +708,7 @@ public static  Observable error(Throwable exception) {
      *         {@link Observer#onError onError} method with the specified
      *         scheduler
      * @see RxJava Wiki: error()
-     * @see MSDN: Observable.Throw Method
+     * @see MSDN: Observable.Throw
      */
     public static  Observable error(Throwable exception, Scheduler scheduler) {
         return Observable. error(exception).subscribeOn(scheduler);
@@ -1065,7 +1065,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * @param count the number of sequential Integers to generate
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
-     * @see Observable.Range Method (Int32, Int32)
+     * @see MSDN: Observable.Range Method (Int32, Int32)
      */
     public static Observable range(int start, int count) {
         return from(Range.createWithCount(start, count));
@@ -1082,7 +1082,7 @@ public static Observable range(int start, int count) {
      * @param scheduler the scheduler to run the generator loop on
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
-     * @see Observable.Range Method (Int32, Int32, IScheduler)
+     * @see MSDN: Observable.Range Method (Int32, Int32, IScheduler)
      */
     public static Observable range(int start, int count, Scheduler scheduler) {
         return from(Range.createWithCount(start, count), scheduler);
@@ -1168,7 +1168,7 @@ public static  Observable just(T value, Scheduler scheduler) {
      *         the items emitted by the Observables emitted by the
      *         {@code source} Observable
      * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     public static  Observable merge(Observable> source) {
         return create(OperationMerge.merge(source));
@@ -1188,7 +1188,7 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1211,7 +1211,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1235,7 +1235,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1260,7 +1260,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1286,7 +1286,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1313,7 +1313,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1341,7 +1341,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1370,7 +1370,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1389,7 +1389,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     public static  Observable concat(Observable> observables) {
         return create(OperationConcat.concat(observables));
@@ -1407,7 +1407,7 @@ public static  Observable concat(ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1428,7 +1428,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1450,7 +1450,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1473,7 +1473,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1497,7 +1497,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1522,7 +1522,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1548,7 +1548,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1575,7 +1575,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: concat()
-     * @see MSDN: Observable.Concat Method
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1605,7 +1605,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     public static  Observable mergeDelayError(Observable> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
@@ -1633,7 +1633,7 @@ public static  Observable mergeDelayError(ObservableRxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1664,7 +1664,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1697,7 +1697,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1730,7 +1730,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1764,7 +1764,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1799,7 +1799,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1835,7 +1835,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -1872,7 +1872,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the {@code source} Observables
      * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge Method
+     * @see MSDN: Observable.Merge
      */
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
@@ -3911,7 +3911,7 @@ public Boolean call(T t1) {
      * @return an Observable that emits the same items as the source Observable,
      *         then invokes the {@link Action0}
      * @see RxJava Wiki: finallyDo()
-     * @see MSDN: Observable.Finally Method
+     * @see MSDN: Observable.Finally
      */
     public Observable finallyDo(Action0 action) {
         return create(OperationFinally.finallyDo(this, action));
@@ -5382,6 +5382,8 @@ public Observable skip(int num) {
      *         Observable that matches the predicate
      * @throws IllegalArgumentException if the source emits more than one item
      *                                  or no items
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.singleAsync()
      */
     public Observable single() {
         return create(OperationSingle. single(this));
@@ -5402,6 +5404,8 @@ public Observable single() {
      * @throws IllegalArgumentException if the source Observable emits more than
      *                                  one item or no items matching the
      *                                  predicate
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.singleAsync()
      */
     public Observable single(Func1 predicate) {
         return filter(predicate).single();
@@ -5420,6 +5424,8 @@ public Observable single(Func1 predicate) {
      * @return an Observable that emits the single item emitted by the source
      *         Observable, or default value if the source Observable is empty
      * @throws IllegalArgumentException if the source emits more than one item
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.singleOrDefaultAsync()
      */
     public Observable singleOrDefault(T defaultValue) {
         return create(OperationSingle. singleOrDefault(this, defaultValue));
@@ -5443,6 +5449,8 @@ public Observable singleOrDefault(T defaultValue) {
      *         emitted item matches the predicate
      * @throws IllegalArgumentException if the source emits more than one item
      *                                  matching the predicate
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.singleOrDefaultAsync()
      */
     public Observable singleOrDefault(T defaultValue, Func1 predicate) {
         return filter(predicate).singleOrDefault(defaultValue);
@@ -5458,6 +5466,7 @@ public Observable singleOrDefault(T defaultValue, Func1 p
      * @return an Observable that emits only the very first item from the
      *         source, or an IllegalArgumentException if the source {@link Observable} is empty.
      * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
      */
     public Observable first() {
         return take(1).single();
@@ -5474,6 +5483,7 @@ public Observable first() {
      * @return an Observable that emits only the very first item satisfying the
      *         given condition from the source, or an IllegalArgumentException if no such items are emitted.
      * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
      */
     public Observable first(Func1 predicate) {
         return takeFirst(predicate).single();
@@ -5491,7 +5501,7 @@ public Observable first(Func1 predicate) {
      *         source, or a default item if the source Observable completes
      *         without emitting a single item
      * @see RxJava Wiki: firstOrDefault()
-     * @see MSDN: Observable.FirstOrDefault
+     * @see MSDN: Observable.firstOrDefaultAsync()
      */
     public Observable firstOrDefault(T defaultValue) {
         return take(1).singleOrDefault(defaultValue);
@@ -5510,7 +5520,7 @@ public Observable firstOrDefault(T defaultValue) {
      * @return an Observable that emits only the very first item from the source
      *         that satisfies the given condition, or a default item otherwise
      * @see RxJava Wiki: firstOrDefault()
-     * @see MSDN: Observable.FirstOrDefault
+     * @see MSDN: Observable.firstOrDefaultAsync()
      */
     public Observable firstOrDefault(T defaultValue, Func1 predicate) {
         return takeFirst(predicate).singleOrDefault(defaultValue);
@@ -5604,7 +5614,7 @@ public Observable takeWhileWithIndex(final Func2take(1) directly.
      * @see RxJava Wiki: first()
-     * @see MSDN: Observable.First
+     * @see MSDN: Observable.firstAsync()
      */
     @Deprecated
     public Observable takeFirst() {
@@ -5623,7 +5633,7 @@ public Observable takeFirst() {
      *         source Observable completes without emitting a single matching
      *         item
      * @see RxJava Wiki: first()
-     * @see MSDN: Observable.First
+     * @see MSDN: Observable.firstAsync()
      */
     public Observable takeFirst(Func1 predicate) {
         return filter(predicate).take(1);
@@ -6267,6 +6277,7 @@ public Observable isEmpty() {
      * @return an Observable that emits the last item from the source Observable
      *         or notifies observers of an error
      * @see RxJava Wiki: last()
+     * @see MSDN: Observable.lastAsync()
      */
     public Observable last() {
         return takeLast(1).single();
@@ -6284,6 +6295,8 @@ public Observable last() {
      *         condition from the source, or an IllegalArgumentException if no
      *         such items are emitted
      * @throws IllegalArgumentException if no such itmes are emmited
+     * @see RxJava Wiki: last()
+     * @see MSDN: Observable.lastAsync()
      */
     public Observable last(Func1 predicate) {
         return filter(predicate).takeLast(1).single();
@@ -6299,6 +6312,8 @@ public Observable last(Func1 predicate) {
      *                     empty
      * @return an Observable that emits only the last item from the source, or a
      *         default item if the source is empty
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.lastOrDefaultAsync()
      */
     public Observable lastOrDefault(T defaultValue) {
         return takeLast(1).singleOrDefault(defaultValue);
@@ -6316,6 +6331,8 @@ public Observable lastOrDefault(T defaultValue) {
      * @param predicate the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item from the source that
      *         satisfies the given condition, or a default item otherwise
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.lastOrDefaultAsync()
      */
     public Observable lastOrDefault(T defaultValue, Func1 predicate) {
         return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 89820b79a4..5e6e3dc46b 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -1,4 +1,4 @@
-/**
+**
  * Copyright 2013 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -36,9 +36,13 @@
 /**
  * An extension of {@link Observable} that provides blocking operators.
  * 
    
- * You construct a BlockingObservable from an Observable with {@link #from(Observable)} or {@link Observable#toBlockingObservable()} 
    
- * The documentation for this interface makes use of a form of marble diagram that has been
- * modified to illustrate blocking operators. The following legend explains these marble diagrams:
+ * You construct a BlockingObservable from an
+ * Observable with {@link #from(Observable)} or
+ * {@link Observable#toBlockingObservable()}
+ * 
    
+ * The documentation for this interface makes use of a form of marble diagram
+ * that has been modified to illustrate blocking operators. The following legend
+ * explains these marble diagrams:
  * 
    
  * 
  * 
    
@@ -64,11 +68,12 @@ public static  BlockingObservable from(final Observable o) {
     }
 
     /**
-     * Used for protecting against errors being thrown from {@link Observer} implementations and
-     * ensuring onNext/onError/onCompleted contract compliance.
+     * Used for protecting against errors being thrown from {@link 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"
+     * 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 observer) {
         SafeObservableSubscription subscription = new SafeObservableSubscription();
@@ -76,20 +81,21 @@ private Subscription protectivelyWrapAndSubscribe(Observer observer)
     }
 
     /**
-     * Invoke a method on each item emitted by the {@link Observable}; block until the Observable
-     * completes.
+     * Invoke a method on each item emitted by the {@link Observable}; block
+     * until the Observable completes.
      * 
    
      * NOTE: This will block even if the Observable is asynchronous.
      * 
    
-     * This is similar to {@link Observable#subscribe(Observer)}, but it blocks. Because it blocks it does
-     * not need the {@link Observer#onCompleted()} or {@link Observer#onError(Throwable)} methods.
+     * This is similar to {@link Observable#subscribe(Observer)}, but it blocks.
+     * Because it blocks it does not need the {@link Observer#onCompleted()} or
+     * {@link Observer#onError(Throwable)} methods.
      * 
    
      * 
      * 
-     * @param onNext
-     *            the {@link Action1} to invoke for every item emitted by the {@link Observable}
-     * @throws RuntimeException
-     *             if an error occurs
+     * @param onNext the {@link Action1} to invoke for every item emitted by the
+     *               {@link Observable}
+     * @throws RuntimeException if an error occurs
+     * @see RxJava Wiki: forEach()
      */
     public void forEach(final Action1 onNext) {
         final CountDownLatch latch = new CountDownLatch(1);
@@ -98,7 +104,8 @@ public void forEach(final Action1 onNext) {
         /**
          * 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"
+         * See https://github.com/Netflix/RxJava/issues/216 for discussion on
+         * "Guideline 6.4: Protect calls to user code from within an operator"
          */
         protectivelyWrapAndSubscribe(new Observer() {
             @Override
@@ -109,10 +116,12 @@ public void onCompleted() {
             @Override
             public void onError(Throwable e) {
                 /*
-                 * If we receive an onError event we set the reference on the outer thread
-                 * so we can git it and throw after the latch.await().
+                 * If we receive an onError event we set the reference on the
+                 * outer thread so we can git it and throw after the
+                 * latch.await().
                  * 
-                 * We do this instead of throwing directly since this may be on a different thread and the latch is still waiting.
+                 * We do this instead of throwing directly since this may be on
+                 * a different thread and the latch is still waiting.
                  */
                 exceptionFromOnError.set(e);
                 latch.countDown();
@@ -144,211 +153,249 @@ public void onNext(T args) {
     }
 
     /**
-     * Returns an {@link Iterator} that iterates over all items emitted by a specified {@link Observable}.
+     * Returns an {@link Iterator} that iterates over all items emitted by a
+     * specified {@link Observable}.
      * 
    
      * 
      * 
-     * @return an {@link Iterator} that can iterate over the items emitted by the {@link Observable}
+     * @return an {@link Iterator} that can iterate over the items emitted by
+     *         the {@link Observable}
+     * @see RxJava Wiki: getIterator()
      */
     public Iterator getIterator() {
         return OperationToIterator.toIterator(o);
     }
 
     /**
-     * Returns the first item emitted by a specified {@link Observable},
-     * or IllegalArgumentException if source contains no elements
+     * Returns the first item emitted by a specified {@link Observable}, or
+     * IllegalArgumentException if source contains no elements.
      * 
      * @return the first item emitted by the source {@link Observable}
-     * @throws IllegalArgumentException
-     *            if source contains no elements
-     * @see MSDN: Observable.First
+     * @throws IllegalArgumentException if source contains no elements
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.First
      */
     public T first() {
         return from(o.first()).single();
     }
 
     /**
-     * Returns the first item emitted by a specified {@link Observable} that matches a predicate,
-     * or IllegalArgumentException if no such items are emitted.
+     * Returns the first item emitted by a specified {@link Observable} that
+     * matches a predicate, or IllegalArgumentException if no such
+     * item is emitted.
      * 
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the first item emitted by the {@link Observable} that matches the predicate
-     * @throws IllegalArgumentException
-     *            if no such items are emitted.
-     * @see MSDN: Observable.First
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the first item emitted by the {@link Observable} that matches the
+     *         predicate
+     * @throws IllegalArgumentException if no such items are emitted
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.First
      */
     public T first(Func1 predicate) {
         return from(o.first(predicate)).single();
     }
 
     /**
-     * Returns the first item emitted by a specified {@link Observable}, or a default value if no
-     * items are emitted.
+     * Returns the first item emitted by a specified {@link Observable}, or a
+     * default value if no items are emitted.
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no items
-     * @return the first item emitted by the {@link Observable}, or the default value if no items
-     *         are emitted
-     * @see MSDN: Observable.FirstOrDefault
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no items
+     * @return the first item emitted by the {@link Observable}, or the default
+     *         value if no items are emitted
+     * @see RxJava Wiki: firstOrDefault()
+     * @see MSDN: Observable.FirstOrDefault
      */
     public T firstOrDefault(T defaultValue) {
         return from(o.take(1)).singleOrDefault(defaultValue);
     }
 
     /**
-     * Returns the first item emitted by a specified {@link Observable} that matches a predicate, or
-     * a default value if no such items are emitted.
+     * Returns the first item emitted by a specified {@link Observable} that
+     * matches a predicate, or a default value if no such items are emitted.
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no matching items
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the first item emitted by the {@link Observable} that matches the predicate, or the
-     *         default value if no matching items are emitted
-     * @see MSDN: Observable.FirstOrDefault
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no matching items
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the first item emitted by the {@link Observable} that matches the
+     *         predicate, or the default value if no matching items are emitted
+     * @see RxJava Wiki: firstOrDefault()
+     * @see MSDN: Observable.FirstOrDefault
      */
     public T firstOrDefault(T defaultValue, Func1 predicate) {
         return from(o.filter(predicate)).firstOrDefault(defaultValue);
     }
 
     /**
-     * Returns the last item emitted by a specified {@link Observable}, or throws IllegalArgumentException
-     * if source contains no elements.
+     * Returns the last item emitted by a specified {@link Observable}, or
+     * throws IllegalArgumentException if it emits no items.
      * 
    
      * 
      * 
      * @return the last item emitted by the source {@link Observable}
      * @throws IllegalArgumentException if source contains no elements
+     * @see RxJava Wiki: last()
+     * @see MSDN: Observable.Last
      */
     public T last() {
         return from(o.last()).single();
     }
 
     /**
-     * Returns the last item emitted by a specified {@link Observable} that matches a predicate,
-     * or throws IllegalArgumentException if no such items are emitted.
+     * Returns the last item emitted by a specified {@link Observable} that
+     * matches a predicate, or throws IllegalArgumentException if
+     * it emits no such items.
      * 
    
      * 
      * 
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the last item emitted by the {@link Observable} that matches the predicate
-     * @throws IllegalArgumentException
-     *            if no such items are emitted.
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the last item emitted by the {@link Observable} that matches the
+     *         predicate
+     * @throws IllegalArgumentException if no such items are emitted
+     * @see RxJava Wiki: last()
+     * @see MSDN: Observable.Last
      */
     public T last(final Func1 predicate) {
         return from(o.last(predicate)).single();
     }
 
     /**
-     * Returns the last item emitted by a specified {@link Observable}, or a default value if no
-     * items are emitted.
+     * Returns the last item emitted by a specified {@link Observable}, or a
+     * default value if no items are emitted.
      * 
    
      * 
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no items
-     * @return the last item emitted by the {@link Observable}, or the default value if no items
-     *         are emitted
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no items
+     * @return the last item emitted by the {@link Observable}, or the default
+     *         value if no items are emitted
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.LastOrDefault
      */
     public T lastOrDefault(T defaultValue) {
         return from(o.takeLast(1)).singleOrDefault(defaultValue);
     }
 
     /**
-     * Returns the last item emitted by a specified {@link Observable} that matches a predicate, or
-     * a default value if no such items are emitted.
+     * Returns the last item emitted by a specified {@link Observable} that
+     * matches a predicate, or a default value if no such items are emitted.
      * 
    
      * 
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no matching items
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the last item emitted by the {@link Observable} that matches the predicate, or the
-     *         default value if no matching items are emitted
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no matching items
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the last item emitted by the {@link Observable} that matches the
+     *         predicate, or the default value if no matching items are emitted
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.LastOrDefault
      */
     public T lastOrDefault(T defaultValue, Func1 predicate) {
         return from(o.filter(predicate)).lastOrDefault(defaultValue);
     }
 
     /**
-     * Returns an {@link Iterable} that always returns the item most recently emitted by an {@link Observable}.
+     * Returns an {@link Iterable} that always returns the item most recently
+     * emitted by an {@link Observable}.
      * 
    
      * 
      * 
-     * @param initialValue
-     *            the initial value that will be yielded by the {@link Iterable} sequence if the {@link Observable} has not yet emitted an item
-     * @return an {@link Iterable} that on each iteration returns the item that the {@link Observable} has most recently emitted
+     * @param initialValue the initial value that will be yielded by the
+     *                     {@link Iterable} sequence if the {@link Observable}
+     *                     has not yet emitted an item
+     * @return an {@link Iterable} that on each iteration returns the item that
+     *         the {@link Observable} has most recently emitted
+     * @see RxJava wiki: mostRecent()
+     * @see MSDN: Observable.MostRecent
      */
     public Iterable mostRecent(T initialValue) {
         return OperationMostRecent.mostRecent(o, initialValue);
     }
 
     /**
-     * Returns an {@link Iterable} that blocks until the {@link Observable} emits another item,
-     * then returns that item.
+     * Returns an {@link Iterable} that blocks until the {@link Observable}
+     * emits another item, then returns that item.
      * 
    
      * 
      * 
      * @return an {@link Iterable} that blocks upon each iteration until the {@link Observable} emits a new item, whereupon the Iterable returns that item
+     * @see RxJava Wiki: next()
+     * @see MSDN: Observable.Next
      */
     public Iterable next() {
         return OperationNext.next(o);
     }
 
     /**
-     * Returns the latest item emitted by the underlying Observable, waiting if necessary
-     * for one to become available.
+     * Returns the latest item emitted by the underlying Observable, waiting if
+     * necessary for one to become available.
      * 
    
-     * If the underlying observable produces items faster than the Iterator.next() takes them
-     * onNext events might be skipped, but onError or onCompleted events are not.
+     * If the underlying Observable produces items faster than the
+     * Iterator.next() takes them, onNext events might
+     * be skipped, but onError or onCompleted events
+     * are not.
      * 
    
-     * Note also that an onNext() directly followed by onCompleted() might hide the onNext() event.
+     * Note also that an onNext() directly followed by
+     * onCompleted() might hide the onNext() event.
      * 
      * @return the Iterable sequence
+     * @see RxJava wiki: latest()
+     * @see MSDN: Observable.Latest
      */
     public Iterable latest() {
         return OperationLatest.latest(o);
     }
     
     /**
-     * If the {@link Observable} completes after emitting a single item, return that item,
-     * otherwise throw an IllegalArgumentException.
+     * If the {@link Observable} completes after emitting a single item, return
+     * that item, otherwise throw an IllegalArgumentException.
      * 
    
      * 
      * 
      * @return the single item emitted by the {@link Observable}
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.Single
      */
     public T single() {
         return from(o.single()).toIterable().iterator().next();
     }
 
     /**
-     * If the {@link Observable} completes after emitting a single item that matches a given
-     * predicate, return that item, otherwise throw an IllegalArgumentException.
+     * If the {@link Observable} completes after emitting a single item that
+     * matches a given predicate, return that item, otherwise throw an
+     * IllegalArgumentException.
      * 
    
      * 
      * 
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the single item emitted by the source {@link Observable} that matches the predicate
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the single item emitted by the source {@link Observable} that
+     *         matches the predicate
+     * @see RxJava Wiki: single()
+     * @see MSDN: Observable.Single
      */
     public T single(Func1 predicate) {
         return from(o.single(predicate)).toIterable().iterator().next();
     }
 
     /**
-     * If the {@link Observable} completes after emitting a single item, return that item; if it
-     * emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.
+     * If the {@link Observable} completes after emitting a single item, return
+     * that item; if it emits more than one item, throw an
+     * IllegalArgumentException; if it emits no items, return a
+     * default value.
      * 
    
      * 
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no items
-     * @return the single item emitted by the {@link Observable}, or the default value if no items
-     *         are emitted
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no items
+     * @return the single item emitted by the {@link Observable}, or the default
+     *         value if no items are emitted
+     * @see RxJava Wiki: singleOrDefault()
+     * @see MSDN: Observable.SingleOrDefault
      */
     public T singleOrDefault(T defaultValue) {
         Iterator it = this.toIterable().iterator();
@@ -365,32 +412,38 @@ public T singleOrDefault(T defaultValue) {
     }
 
     /**
-     * If the {@link Observable} completes after emitting a single item that matches a predicate,
-     * return that item; if it emits more than one such item, throw an IllegalArgumentException; if it emits no
+     * If the {@link Observable} completes after emitting a single item that
+     * matches a predicate, return that item; if it emits more than one such
+     * item, throw an IllegalArgumentException; if it emits no
      * items, return a default value.
      * 
    
      * 
      * 
-     * @param defaultValue
-     *            a default value to return if the {@link Observable} emits no matching items
-     * @param predicate
-     *            a predicate function to evaluate items emitted by the {@link Observable}
-     * @return the single item emitted by the {@link Observable} that matches the predicate, or the
-     *         default value if no such items are emitted
+     * @param defaultValue a default value to return if the {@link Observable}
+     *                     emits no matching items
+     * @param predicate a predicate function to evaluate items emitted by the
+     *                  {@link Observable}
+     * @return the single item emitted by the {@link Observable} that matches
+     *         the predicate, or the default value if no such items are emitted
+     * @see RxJava Wiki: singleOrDefault()
+     * @see MSDN: Observable.SingleOrDefault
      */
     public T singleOrDefault(T defaultValue, Func1 predicate) {
         return from(o.filter(predicate)).singleOrDefault(defaultValue);
     }
 
     /**
-     * Returns a {@link Future} representing the single value emitted by an {@link Observable}.
+     * Returns a {@link Future} representing the single value emitted by an
+     * {@link Observable}.
      * 
    
-     * toFuture() throws an exception if the Observable emits more than one item. If
-     * the Observable may emit more than item, use {@link Observable#toList toList()}.toFuture().
+     * toFuture() throws an exception if the Observable emits more
+     * than one item. If the Observable may emit more than item, use
+     * {@link Observable#toList toList()}.toFuture().
      * 
    
      * 
      * 
      * @return a {@link Future} that expects a single item to be emitted by the source {@link Observable}
+     * @see RxJava Wiki: toFuture()
      */
     public Future toFuture() {
         return OperationToFuture.toFuture(o);
@@ -402,6 +455,7 @@ public Future toFuture() {
      * 
      * 
      * @return an {@link Iterable} version of the underlying {@link Observable}
+     * @see RxJava Wiki: toIterable()
      */
     public Iterable toIterable() {
         return new Iterable() {
@@ -412,3 +466,4 @@ public Iterator iterator() {
         };
     }
 }
+

From 513a6b7d7d7b6035de395b0881b4cbc0cac81122 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 26 Dec 2013 16:06:55 -0800
Subject: [PATCH 144/441] correcting typo causing build failure

---
 .../src/main/java/rx/observables/BlockingObservable.java        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 5e6e3dc46b..87f5fe63b2 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -1,4 +1,4 @@
-**
+/**
  * Copyright 2013 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");

From c497423cc4ad55d1e61f4c0863a575adfda10f5f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 12:11:06 -0800
Subject: [PATCH 145/441] Remove ObserverBase Import

Was unused and causing build break once that class was removed.
---
 .../rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala     | 2 --
 1 file changed, 2 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala
index 5f290404f8..eb9efa02ac 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subject.scala
@@ -15,8 +15,6 @@
  */
 package rx.lang.scala
 
-import rx.joins.ObserverBase
-
 /**
 * A Subject is an Observable and an Observer at the same time.
 */

From 3bba2459d4c5b54dc2ac78a8331b1d1343941bb8 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 13:11:46 -0800
Subject: [PATCH 146/441] Remove newly added aggregate methods

- avoiding methods with `index`
- resultSelector overload is same as `reduce(seed, accumulator).map(resultSelector)`
---
 rxjava-core/src/main/java/rx/Observable.java  |  45 +----
 .../java/rx/operators/OperationAggregate.java | 158 ------------------
 ...gateTest.java => OperationReduceTest.java} |  36 +---
 3 files changed, 5 insertions(+), 234 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationAggregate.java
 rename rxjava-core/src/test/java/rx/operators/{OperationAggregateTest.java => OperationReduceTest.java} (73%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e51093279a..1b70d42984 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5327,7 +5327,7 @@ public Observable aggregate(Func2 accumulator) {
     public  Observable reduce(R initialValue, Func2 accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
-
+    
     /**
      * Synonymous with reduce().
      * 
    
@@ -5341,49 +5341,6 @@ public  Observable aggregate(R initialValue, Func2 accumu
         return reduce(initialValue, accumulator);
     }
     
-    /**
-     * Create an Observable that aggregates the source values with the given accumulator
-     * function and projects the final result via the resultselector.
-     * 
    
-     * Works like the {@link #aggregate(java.lang.Object, rx.util.functions.Func2)} projected
-     * with {@link #map(rx.util.functions.Func1)} without the overhead of some helper
-     * operators.
-     * @param  the intermediate (accumulator) type
-     * @param  the result type
-     * @param seed the initial value of the accumulator
-     * @param accumulator the function that takes the current accumulator value,
-     *                    the current emitted value and returns a (new) accumulated value.
-     * @param resultSelector the selector to project the final value of the accumulator
-     * @return an Observable that aggregates the source values with the given accumulator
-     *         function and projects the final result via the resultselector
-     */
-    public  Observable aggregate(
-            U seed, Func2 accumulator, 
-            Func1 resultSelector) {
-        return create(new OperationAggregate.AggregateSelector(this, seed, accumulator, resultSelector));
-    }
-    
-    /**
-     * Create an Observable that aggregates the source values with the given indexed accumulator
-     * function and projects the final result via the indexed resultselector.
-     * 
-     * @param  the intermediate (accumulator) type
-     * @param  the result type
-     * @param seed the initial value of the accumulator
-     * @param accumulator the function that takes the current accumulator value,
-     *                    the current emitted value and returns a (new) accumulated value.
-     * @param resultSelector the selector to project the final value of the accumulator, where
-     *                       the second argument is the total number of elements accumulated
-     * @return an Observable that aggregates the source values with the given indexed accumulator
-     * function and projects the final result via the indexed resultselector.
-     */
-    public  Observable aggregateIndexed(
-            U seed, Func3 accumulator,
-        Func2 resultSelector
-    ) {
-        return create(new OperationAggregate.AggregateIndexedSelector(this, seed, accumulator, resultSelector));
-    }
-
     /**
      * 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
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAggregate.java b/rxjava-core/src/main/java/rx/operators/OperationAggregate.java
deleted file mode 100644
index 71778cccf1..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationAggregate.java
+++ /dev/null
@@ -1,158 +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.operators;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
-
-/**
- * Aggregate overloads with index and selector functions.
- */
-public final class OperationAggregate {
-    /** Utility class. */
-    private OperationAggregate() { throw new IllegalStateException("No instances!"); }
-    
-    /**
-     * Aggregate and emit a value after running it through a selector.
-     * @param  the input value type
-     * @param  the intermediate value type
-     * @param  the result value type
-     */
-    public static final class AggregateSelector implements OnSubscribeFunc {
-        final Observable source;
-        final U seed;
-        final Func2 aggregator;
-        final Func1 resultSelector;
-
-        public AggregateSelector(
-                Observable source, U seed, 
-                Func2 aggregator, 
-                Func1 resultSelector) {
-            this.source = source;
-            this.seed = seed;
-            this.aggregator = aggregator;
-            this.resultSelector = resultSelector;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new AggregatorObserver(t1, seed));
-        }
-        /** The aggregator observer of the source. */
-        private final class AggregatorObserver implements Observer {
-            final Observer observer;
-            U accumulator;
-            public AggregatorObserver(Observer observer, U seed) {
-                this.observer = observer;
-                this.accumulator = seed;
-            }
-
-            @Override
-            public void onNext(T args) {
-                accumulator = aggregator.call(accumulator, args);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                accumulator = null;
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                U a = accumulator;
-                accumulator = null;
-                try {
-                    observer.onNext(resultSelector.call(a));
-                } catch (Throwable t) {
-                    observer.onError(t);
-                    return;
-                }
-                observer.onCompleted();
-            }
-        }
-    }
-    /**
-     * Indexed aggregate and emit a value after running it through an indexed selector.
-     * @param  the input value type
-     * @param  the intermediate value type
-     * @param  the result value type
-     */
-    public static final class AggregateIndexedSelector implements OnSubscribeFunc {
-        final Observable source;
-        final U seed;
-        final Func3 aggregator;
-        final Func2 resultSelector;
-
-        public AggregateIndexedSelector(
-                Observable source, 
-                U seed, 
-                Func3 aggregator, 
-                Func2 resultSelector) {
-            this.source = source;
-            this.seed = seed;
-            this.aggregator = aggregator;
-            this.resultSelector = resultSelector;
-        }
-
-        
-        
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new AggregatorObserver(t1, seed));
-        }
-        /** The aggregator observer of the source. */
-        private final class AggregatorObserver implements Observer {
-            final Observer observer;
-            U accumulator;
-            int index;
-            public AggregatorObserver(Observer observer, U seed) {
-                this.observer = observer;
-                this.accumulator = seed;
-            }
-
-            @Override
-            public void onNext(T args) {
-                accumulator = aggregator.call(accumulator, args, index++);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                accumulator = null;
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                U a = accumulator;
-                accumulator = null;
-                try {
-                    observer.onNext(resultSelector.call(a, index));
-                } catch (Throwable t) {
-                    observer.onError(t);
-                    return;
-                }
-                observer.onCompleted();
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
similarity index 73%
rename from rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java
rename to rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
index 749af5b235..9f3e780e67 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAggregateTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
@@ -45,41 +45,13 @@ public Integer call(Integer t1, Integer t2) {
     @Test
     public void testAggregateAsIntSum() {
         
-        Observable result = Observable.from(1, 2, 3, 4, 5).aggregate(0, sum, Functions.identity());
+        Observable result = Observable.from(1, 2, 3, 4, 5).reduce(0, sum).map(Functions.identity());
         
         result.subscribe(observer);
         
         verify(observer).onNext(1 + 2 + 3 + 4 + 5);
         verify(observer).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
-    }
-    
-    @Test
-    public void testAggregateIndexedAsAverage() {
-        Func3 sumIndex = new Func3() {
-            @Override
-            public Integer call(Integer acc, Integer value, Integer index) {
-                return acc + (index + 1) + value;
-            }
-        };
-        Func2 selectIndex = new Func2() {
-            @Override
-            public Integer call(Integer t1, Integer count) {
-                return t1 + count;
-            }
-            
-        };
-        
-        Observable result = Observable.from(1, 2, 3, 4, 5)
-            .aggregateIndexed(0, sumIndex, selectIndex);
-        
-        result.subscribe(observer);
-        
-        verify(observer).onNext(2 + 4 + 6 + 8 + 10 + 5);
-        verify(observer).onCompleted();
-        verify(observer, never()).onError(any(Throwable.class));
-        
     }
     
     static class CustomException extends RuntimeException { }
@@ -88,7 +60,7 @@ static class CustomException extends RuntimeException { }
     public void testAggregateAsIntSumSourceThrows() {
         Observable result = Observable.concat(Observable.from(1, 2, 3, 4, 5),
             Observable.error(new CustomException()))
-            .aggregate(0, sum, Functions.identity());
+            .reduce(0, sum).map(Functions.identity());
         
         result.subscribe(observer);
         
@@ -107,7 +79,7 @@ public Integer call(Integer t1, Integer t2) {
         };
         
         Observable result = Observable.from(1, 2, 3, 4, 5)
-            .aggregate(0, sumErr, Functions.identity());
+            .reduce(0, sumErr).map(Functions.identity());
         
         result.subscribe(observer);
         
@@ -128,7 +100,7 @@ public Integer call(Integer t1) {
         };
         
         Observable result = Observable.from(1, 2, 3, 4, 5)
-            .aggregate(0, sum, error);
+            .reduce(0, sum).map(error);
         
         result.subscribe(observer);
         

From c451ce9eb3eab48c0e848c8371f1b92b1128249a Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 13:12:42 -0800
Subject: [PATCH 147/441] Rename to ReduceTest

---
 rxjava-core/src/main/java/rx/Observable.java     |  1 -
 .../java/rx/operators/OperationAverageTest.java  |  2 +-
 .../java/rx/operators/OperationReduceTest.java   |  8 +++++---
 .../test/java/rx/operators/OperationSumTest.java | 16 ++++++++--------
 4 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 1b70d42984..6ad27fa409 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -32,7 +32,6 @@
 import rx.observables.BlockingObservable;
 import rx.observables.ConnectableObservable;
 import rx.observables.GroupedObservable;
-import rx.operators.OperationAggregate;
 import rx.operators.OperationAll;
 import rx.operators.OperationAmb;
 import rx.operators.OperationAny;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
index 8655c37437..c0d7ac9366 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
@@ -22,7 +22,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperationAggregateTest.CustomException;
+import rx.operators.OperationReduceTest.CustomException;
 import rx.util.functions.Func1;
 
 public class OperationAverageTest {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
index 9f3e780e67..c067f40179 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
@@ -16,19 +16,21 @@
 
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import static org.mockito.Mockito.*;
+
 import rx.Observable;
 import rx.Observer;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
-import rx.util.functions.Func3;
 import rx.util.functions.Functions;
 
-public class OperationAggregateTest {
+public class OperationReduceTest {
     @Mock
     Observer observer;
     @Before
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index 2fcc4611e1..78aee09ede 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -269,7 +269,7 @@ public void testIntegerSumSelectorThrows() {
         Func1 length = new Func1() {
             @Override
             public Integer call(String t1) {
-                throw new OperationAggregateTest.CustomException();
+                throw new OperationReduceTest.CustomException();
             }
         };
         
@@ -277,7 +277,7 @@ public Integer call(String t1) {
         Observer o = mock(Observer.class);
         result.subscribe(o);
         
-        testThrows(o, OperationAggregateTest.CustomException.class);
+        testThrows(o, OperationReduceTest.CustomException.class);
     }
     @Test
     public void testLongSumSelectorThrows() {
@@ -285,7 +285,7 @@ public void testLongSumSelectorThrows() {
         Func1 length = new Func1() {
             @Override
             public Long call(String t1) {
-                throw new OperationAggregateTest.CustomException();
+                throw new OperationReduceTest.CustomException();
             }
         };
         
@@ -293,7 +293,7 @@ public Long call(String t1) {
         Observer o = mock(Observer.class);
         result.subscribe(o);
         
-        testThrows(o, OperationAggregateTest.CustomException.class);
+        testThrows(o, OperationReduceTest.CustomException.class);
     }
     @Test
     public void testFloatSumSelectorThrows() {
@@ -301,7 +301,7 @@ public void testFloatSumSelectorThrows() {
         Func1 length = new Func1() {
             @Override
             public Float call(String t1) {
-                throw new OperationAggregateTest.CustomException();
+                throw new OperationReduceTest.CustomException();
             }
         };
         
@@ -309,7 +309,7 @@ public Float call(String t1) {
         Observer o = mock(Observer.class);
         result.subscribe(o);
         
-        testThrows(o, OperationAggregateTest.CustomException.class);
+        testThrows(o, OperationReduceTest.CustomException.class);
     }
     @Test
     public void testDoubleSumSelectorThrows() {
@@ -317,7 +317,7 @@ public void testDoubleSumSelectorThrows() {
         Func1 length = new Func1() {
             @Override
             public Double call(String t1) {
-                throw new OperationAggregateTest.CustomException();
+                throw new OperationReduceTest.CustomException();
             }
         };
         
@@ -325,6 +325,6 @@ public Double call(String t1) {
         Observer o = mock(Observer.class);
         result.subscribe(o);
         
-        testThrows(o, OperationAggregateTest.CustomException.class);
+        testThrows(o, OperationReduceTest.CustomException.class);
     }
 }

From 18ea25a7f90e68a8d3471d21268d25747d9c4b99 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Fri, 27 Dec 2013 13:20:30 -0800
Subject: [PATCH 148/441] javadoc improvements: * diagrams for skip(t),
 single(), take(t), skipLast(t) * minor corrections, reformatting of javadoc
 comments

---
 rxjava-core/src/main/java/rx/Observable.java | 134 +++++++++++--------
 1 file changed, 81 insertions(+), 53 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 78d49425c9..ac7b09f078 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -352,6 +352,7 @@ public void onNext(T args) {
      * 
      * @param onNext
      * @return 
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext) {
         if (onNext == null) {
@@ -391,6 +392,7 @@ public void onNext(T args) {
      * @param onNext
      * @param scheduler
      * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext);
@@ -403,6 +405,7 @@ public Subscription subscribe(final Action1 onNext, Scheduler schedul
      * @param onNext
      * @param onError
      * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext, final Action1 onError) {
         if (onNext == null) {
@@ -447,6 +450,7 @@ public void onNext(T args) {
      * @param onError
      * @param scheduler
      * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError);
@@ -460,6 +464,7 @@ public Subscription subscribe(final Action1 onNext, final Action1RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) {
         if (onNext == null) {
@@ -507,6 +512,7 @@ public void onNext(T args) {
      * @param onComplete
      * @param scheduler
      * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
@@ -519,7 +525,7 @@ public Subscription subscribe(final Action1 onNext, final Action1 asObservable() {
          return create(new OperationAsObservable(this));
      }
-    
+
     /**
      * Returns a {@link ConnectableObservable} that upon connection causes the
      * source Observable to push results into the specified subject.
@@ -641,6 +647,7 @@ public Subscription onSubscribe(Observer observer) {
      * @return an Observable that, when an {@link Observer} subscribes to it,
      *         will execute the given function
      * @see RxJava Wiki: create()
+     * @see MSDN: Observable.Create
      */
     public static  Observable create(OnSubscribeFunc func) {
         return new Observable(func);
@@ -1074,7 +1081,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * @param count the number of sequential Integers to generate
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
-     * @see MSDN: Observable.Range Method (Int32, Int32)
+     * @see MSDN: Observable.Range
      */
     public static Observable range(int start, int count) {
         return from(Range.createWithCount(start, count));
@@ -1091,7 +1098,7 @@ public static Observable range(int start, int count) {
      * @param scheduler the scheduler to run the generator loop on
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
-     * @see MSDN: Observable.Range Method (Int32, Int32, IScheduler)
+     * @see MSDN: Observable.Range
      */
     public static Observable range(int start, int count, Scheduler scheduler) {
         return from(Range.createWithCount(start, count), scheduler);
@@ -5382,29 +5389,30 @@ public Observable skip(int num) {
 
     /**
      * Create an Observable that skips values before the given time ellapses.
+     * 
    
+     * 
      * 
-     * @param time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
+     * @param time the length of the time window
+     * @param unit the time unit
      * @return an Observable that skips values before the given time ellapses
+     * @see RxJava Wiki: skip()
      */
     public Observable skip(long time, TimeUnit unit) {
         return skip(time, unit, Schedulers.threadPoolForComputation());
     }
  
     /**
-     * Create an Observable that skips values before the given time
-     * elapses while waiting on the given scheduler.
+     * Create an Observable that skips values before the given time elapses
+     * while waiting on the given scheduler.
+     * 
    
+     * 
      * 
-     * @param time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the scheduler where the timed wait happens
-     * @return an Observable that skips values before the given time
-     *         elapses while waiting on the given scheduler
+     * @param time the length of the time window
+     * @param unit the time unit
+     * @param scheduler the scheduler where the timed wait happens
+     * @return an Observable that skips values before the given time elapses
+     *         while waiting on the given scheduler
+     * @see RxJava Wiki: skip()
      */
     public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
@@ -5414,12 +5422,13 @@ public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
      * If the Observable completes after emitting a single item, return an
      * Observable containing that item. If it emits more than one item or no
      * item, throw an IllegalArgumentException.
+     * 
    
+     * 
      * 
      * @return an Observable that emits the single item emitted by the source
      *         Observable that matches the predicate
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item
-     *             or no items
+     * @throws IllegalArgumentException if the source emits more than one item
+     *                                  or no items
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleAsync()
      */
@@ -5605,29 +5614,38 @@ public Observable take(final int num) {
     }
 
     /**
-      * Create an Observable that takes the emitted values of the source
-      * Observable before the time runs out.
-      * @param time the length of the time window
-      * @param unit the time unit
-      * @return an Observable that takes the emitted values of the source
-      *         Observable before the time runs out.
-      */
-     public Observable take(long time, TimeUnit unit) {
-         return take(time, unit, Schedulers.threadPoolForComputation());
-     }
+     * Create an Observable that emits the emitted items from the source
+     * Observable before the time runs out.
+     * 
    
+     * 
+     * 
+     * @param time the length of the time window
+     * @param unit the time unit
+     * @return an Observable that emits the emitted items from the source
+     *         Observable before the time runs out
+     * @see RxJava Wiki: take()
+     */
+    public Observable take(long time, TimeUnit unit) {
+        return take(time, unit, Schedulers.threadPoolForComputation());
+    }
      
-     /**
-      * Create an Observable that takes the emitted values of the source
-      * Observable before the time runs out, waiting on the given scheduler.
-      * @param time the length of the time window
-      * @param unit the time unit
-      * @param scheduler the scheduler used for time source
-      * @return an Observable that takes the emitted values of the source
-      *         Observable before the time runs out, waiting on the given scheduler.
-      */
-     public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
-         return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
-     }
+    /**
+     * Create an Observable that emits the emitted items from the source
+     * Observable before the time runs out, waiting on the given scheduler.
+     * 
    
+     * 
+     * 
+     * @param time the length of the time window
+     * @param unit the time unit
+     * @param scheduler the scheduler used for time source
+     * @return an Observable that emits the emitted items from the source
+     *         Observable before the time runs out, waiting on the given
+     *         scheduler
+     * @see RxJava Wiki: take()
+     */
+    public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
+    }
  
     /**
      * Returns an Observable that emits items emitted by the source Observable
@@ -5972,25 +5990,35 @@ public Observable skipLast(int count) {
     }
 
     /**
-     * Create an observable which skips values emitted in a time window
-     * before the source completes.
+     * Create an Observable that skips values emitted in a time window before
+     * the source completes.
+     * 
    
+     * 
+     *
      * @param time the length of the time window
      * @param unit the time unit
-     * @return an observable which skips values emitted in a time window
-     * before the source completes
+     * @return an Observable that skips values emitted in a time window before
+     *         the source completes
+     * @see RxJava Wiki: skipLast()
+     * @see MSDN: Observable.SkipLast
      */
     public Observable skipLast(long time, TimeUnit unit) {
         return skipLast(time, unit, Schedulers.threadPoolForComputation());
     }
     
     /**
-     * Create an observable which skips values emitted in a time window
-     * before the source completes by using the given scheduler as time source.
+     * Create an Observable that skips values emitted in a time window before
+     * the source completes by using the given scheduler as time source.
+     * 
    
+     * 
+     *
      * @param time the length of the time window
      * @param unit the time unit
      * @param scheduler the scheduler used for time source
-     * @return an observable which skips values emitted in a time window
-     * before the source completes by using the given scheduler as time source
+     * @return an Observable that skips values emitted in a time window before
+     *         the source completes by using the given scheduler as time source
+     * @see RxJava Wiki: skipLast()
+     * @see MSDN: Observable.SkipLast
      */
     public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
@@ -6894,8 +6922,8 @@ public void onNext(T args) { }
      * 
    
      * 
      *
-     * @param onCompleted the action to invoke when the source Observable calls
-     *                    onCompleted
+     * @param onNext the action to invoke when the source Observable calls
+     *               onNext
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnNext()
      * @see MSDN: Observable.Do
@@ -6958,7 +6986,7 @@ public void onNext(T v) {
      * 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.

From 0e6be528cb96b168513de9979baed25e888d60a4 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Fri, 27 Dec 2013 13:44:06 -0800
Subject: [PATCH 149/441] Adding diagrams, improving javadocs for
 sumFoo/averageFoo operators.

---
 rxjava-core/src/main/java/rx/Observable.java | 138 +++++++++++++------
 1 file changed, 97 insertions(+), 41 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 8d5f487ad0..079939348d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4412,49 +4412,77 @@ public static Observable sumDoubles(Observable source) {
         return OperationSum.sumDoubles(source);
     }
 
-        /**
-     * Create an Observable that extracts integer values from this Observable via
-     * the provided function and computes the integer sum of the value sequence.
+    /**
+     * Create an Observable that extracts an integer from each of the items
+     * emitted by the source Observable via a function you specify, and then
+     * emits the sum of these integers.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an integer from this Observable
-     * @return an Observable that extracts integer values from this Observable via
-     * the provided function and computes the integer sum of the value sequence.
+     * @param valueExtractor the function to extract an integer from each item
+     *                       emitted by the source Observable
+     * @return an Observable that emits the integer sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumInteger()
+     * @see MSDN: Observable.Sum
      */
     public Observable sumInteger(Func1 valueExtractor) {
         return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts long values from this Observable via
-     * the provided function and computes the long sum of the value sequence.
+     * Create an Observable that extracts a long from each of the items emitted
+     * by the source Observable via a function you specify, and then emits the
+     * sum of these longs.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an long from this Observable
-     * @return an Observable that extracts long values from this Observable via
-     * the provided function and computes the long sum of the value sequence.
+     * @param valueExtractor the function to extract a long from each item
+     *                       emitted by the source Observable
+     * @return an Observable that emits the long sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumLong()
+     * @see MSDN: Observable.Sum
      */
     public Observable sumLong(Func1 valueExtractor) {
         return create(new OperationSum.SumLongExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts float values from this Observable via
-     * the provided function and computes the float sum of the value sequence.
+     * Create an Observable that extracts a float from each of the items emitted
+     * by the source Observable via a function you specify, and then emits the
+     * sum of these floats.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an float from this Observable
-     * @return an Observable that extracts float values from this Observable via
-     * the provided function and computes the float sum of the value sequence.
+     * @param valueExtractor the function to extract a float from each item
+     *                       emitted by the source Observable
+     * @return an Observable that emits the float sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumFloat()
+     * @see MSDN: Observable.Sum
      */
     public Observable sumFloat(Func1 valueExtractor) {
         return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts double values from this Observable via
-     * the provided function and computes the double sum of the value sequence.
+     * Create an Observable that extracts a double from each of the items
+     * emitted by the source Observable via a function you specify, and then
+     * emits the sum of these doubles.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an double from this Observable
-     * @return an Observable that extracts double values from this Observable via
-     * the provided function and computes the double sum of the value sequence.
+     * @param valueExtractor the function to extract a double from each item
+     *                       emitted by the source Observable
+     * @return an Observable that emits the double sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumDouble()
+     * @see MSDN: Observable.Sum
      */
     public Observable sumDouble(Func1 valueExtractor) {
         return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
@@ -4526,48 +4554,76 @@ public static Observable averageDoubles(Observable source) {
     }
 
     /**
-     * Create an Observable that extracts integer values from this Observable via
-     * the provided function and computes the integer average of the value sequence.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into integers by using a function you provide and then emits
+     * the integer average of the complete sequence of transformed values.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an integer from this Observable
-     * @return an Observable that extracts integer values from this Observable via
-     * the provided function and computes the integer average of the value sequence.
+     * @param valueExtractor the function to transform an item emitted by the
+     *                       source Observable into an integer
+     * @return an Observable that emits the integer average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into integers by the specified function
+     * @see RxJava Wiki: averageInteger()
+     * @see MSDN: Observable.Average
      */
     public Observable averageInteger(Func1 valueExtractor) {
         return create(new OperationAverage.AverageIntegerExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts long values from this Observable via
-     * the provided function and computes the long average of the value sequence.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into longs by using a function you provide and then emits
+     * the long average of the complete sequence of transformed values.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an long from this Observable
-     * @return an Observable that extracts long values from this Observable via
-     * the provided function and computes the long average of the value sequence.
+     * @param valueExtractor the function to transform an item emitted by the
+     *                       source Observable into a long
+     * @return an Observable that emits the long average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into longs by the specified function
+     * @see RxJava Wiki: averageLong()
+     * @see MSDN: Observable.Average
      */
     public Observable averageLong(Func1 valueExtractor) {
         return create(new OperationAverage.AverageLongExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts float values from this Observable via
-     * the provided function and computes the float average of the value sequence.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into floats by using a function you provide and then emits
+     * the float average of the complete sequence of transformed values.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an float from this Observable
-     * @return an Observable that extracts float values from this Observable via
-     * the provided function and computes the float average of the value sequence.
+     * @param valueExtractor the function to transform an item emitted by the
+     *                       source Observable into a float
+     * @return an Observable that emits the float average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into floats by the specified function
+     * @see RxJava Wiki: averageFloat()
+     * @see MSDN: Observable.Average
      */
     public Observable averageFloat(Func1 valueExtractor) {
         return create(new OperationAverage.AverageFloatExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that extracts double values from this Observable via
-     * the provided function and computes the double average of the value sequence.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into doubles by using a function you provide and then emits
+     * the double average of the complete sequence of transformed values.
+     * 
    
+     * 
      * 
-     * @param valueExtractor the function to extract an double from this Observable
-     * @return an Observable that extracts double values from this Observable via
-     * the provided function and computes the double average of the value sequence.
+     * @param valueExtractor the function to transform an item emitted by the
+     *                       source Observable into a double
+     * @return an Observable that emits the double average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into doubles by the specified function
+     * @see RxJava Wiki: averageDouble()
+     * @see MSDN: Observable.Average
      */
     public Observable averageDouble(Func1 valueExtractor) {
         return create(new OperationAverage.AverageDoubleExtractor(this, valueExtractor));

From d3a0daa573a6e917f309dca719cdf6f23105ee7d Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Fri, 27 Dec 2013 13:48:05 -0800
Subject: [PATCH 150/441] adding diagram to repeat() javadocs

---
 rxjava-core/src/main/java/rx/Observable.java | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d1e2e17a56..68ebe753ad 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1108,20 +1108,27 @@ public static Observable range(int start, int count, Scheduler schedule
     /**
      * Repeats the observable sequence indefinitely.
      * 
    
+     * 
      *
-     * @return The observable sequence producing the elements of the given sequence repeatedly and sequentially.
-     * @see MSDN: Observable.Repeat
+     * @return an Observable that emits the items emitted by the source
+     *         Observable repeatedly and in sequence
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
      */
     public Observable repeat() {
         return this.repeat(Schedulers.currentThread());
     }
 
     /**
-     * Repeats the observable sequence indefinitely.
+     * Repeats the observable sequence indefinitely, on a particular scheduler.
      * 
    
+     * 
+     * 
      * @param scheduler the scheduler to send the values on.
-     * @return The observable sequence producing the elements of the given sequence repeatedly and sequentially.
-     * @see MSDN: Observable.Repeat
+     * @return an Observable that emits the items emitted by the source
+     *         Observable repeatedly and in sequence
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
      */
     public Observable repeat(Scheduler scheduler) {
         return create(OperationRepeat.repeat(this, scheduler));

From fd6dd169e6e119f72d65042f3adb947623ae2766 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 13:57:04 -0800
Subject: [PATCH 151/441] Collect Operator

---
 rxjava-core/src/main/java/rx/Observable.java  | 25 ++++++++++++++
 .../src/test/java/rx/ObservableTests.java     | 33 +++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 9027fcc147..4697669977 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -15,6 +15,7 @@
  */
 package rx;
 
+import static org.junit.Assert.*;
 import static rx.util.functions.Functions.*;
 
 import java.util.ArrayList;
@@ -123,6 +124,7 @@
 import rx.util.Timestamped;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
+import rx.util.functions.Action2;
 import rx.util.functions.Async;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
@@ -5350,6 +5352,29 @@ public  Observable reduce(R initialValue, Func2 accumulat
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
     
+    /**
+     * Collect values into a single mutable data structure.
+     * 
    
+     * A simplified version of `reduce` that does not need to return the state on each pass.
+     * 
    
+     * 
+     * @param state
+     * @param collector
+     * @return
+     */
+    public  Observable collect(R state, final Action2 collector) {
+        Func2 accumulator = new Func2() {
+
+            @Override
+            public R call(R state, T value) {
+                collector.call(state, value);
+                return state;
+            }
+
+        };
+        return reduce(state, accumulator);
+    }
+    
     /**
      * Synonymous with reduce().
      * 
    
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index cd5a985104..22e0f9cd60 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -43,6 +43,7 @@
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action1;
+import rx.util.functions.Action2;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
@@ -1091,5 +1092,37 @@ public String answer(InvocationOnMock invocation) throws Throwable {
 
         verify(func, times(1)).call();
     }
+    
+    @Test
+    public void testCollectToList() {
+        List list = Observable.from(1, 2, 3).collect(new ArrayList(), new Action2, Integer>() {
+
+            @Override
+            public void call(List list, Integer v) {
+                list.add(v);
+            }
+        }).toBlockingObservable().last();
+
+        assertEquals(3, list.size());
+        assertEquals(1, list.get(0).intValue());
+        assertEquals(2, list.get(1).intValue());
+        assertEquals(3, list.get(2).intValue());
+    }
+
+    @Test
+    public void testCollectToString() {
+        String value = Observable.from(1, 2, 3).collect(new StringBuilder(), new Action2() {
+
+            @Override
+            public void call(StringBuilder sb, Integer v) {
+                if (sb.length() > 0) {
+                    sb.append("-");
+                }
+                sb.append(v);
+            }
+        }).toBlockingObservable().last().toString();
+
+        assertEquals("1-2-3", value);
+    }
 
 }

From 2f8c5085249a225fe030b6d38a08f381dfb87470 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 14:45:42 -0800
Subject: [PATCH 152/441] Mark as Deprecated

---
 rxjava-core/src/main/java/rx/operators/OperationMap.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationMap.java b/rxjava-core/src/main/java/rx/operators/OperationMap.java
index 4277edfd1d..5233d9a798 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMap.java
@@ -67,6 +67,7 @@ public R call(T value, @SuppressWarnings("unused") Integer unused) {
      * @param 
      *            the type of the output sequence.
      * @return a sequence that is the result of applying the transformation function to each item in the input sequence.
+     * @deprecated
      */
     public static  OnSubscribeFunc mapWithIndex(final Observable sequence, final Func2 func) {
         return new OnSubscribeFunc() {

From d107ebaa37de645529e2512bfbe51153a96e9ee1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 14:46:33 -0800
Subject: [PATCH 153/441] Remove Extra Synchronization

The use of flatMap/mergeMap already synchronizes.
---
 rxjava-core/src/main/java/rx/operators/OperationParallel.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallel.java b/rxjava-core/src/main/java/rx/operators/OperationParallel.java
index 32ad3181f3..4db3b8e6b6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationParallel.java
@@ -46,13 +46,13 @@ public Integer call(T t) {
                         return i.incrementAndGet() % s.degreeOfParallelism();
                     }
 
-                }).flatMap(new Func1, Observable>() {
+                }).mergeMap(new Func1, Observable>() {
 
                     @Override
                     public Observable call(GroupedObservable group) {
                         return f.call(group.observeOn(s));
                     }
-                }).synchronize();
+                });
             }
         });
     }

From f8fc1cb4c23f4782605451bfc0cea043b6a5e7e4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 14:59:23 -0800
Subject: [PATCH 154/441] Standardize Naming of average/sum methods

See https://github.com/Netflix/RxJava/pull/698#issuecomment-31282416
---
 rxjava-core/src/main/java/rx/Observable.java | 22 ++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4697669977..d34be01392 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4378,6 +4378,11 @@ public Integer call(Integer t1, T t2) {
      * @see RxJava Wiki: sum()
      * @see MSDN: Observable.Sum
      */
+    public static Observable sumInteger(Observable source) {
+        return OperationSum.sum(source);
+    }
+    
+    @Deprecated
     public static Observable sum(Observable source) {
         return OperationSum.sum(source);
     }
@@ -4394,7 +4399,7 @@ public static Observable sum(Observable source) {
      * @see RxJava Wiki: sumLongs()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumLongs(Observable source) {
+    public static Observable sumLong(Observable source) {
         return OperationSum.sumLongs(source);
     }
 
@@ -4410,7 +4415,7 @@ public static Observable sumLongs(Observable source) {
      * @see RxJava Wiki: sumFloats()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumFloats(Observable source) {
+    public static Observable sumFloat(Observable source) {
         return OperationSum.sumFloats(source);
     }
 
@@ -4426,7 +4431,7 @@ public static Observable sumFloats(Observable source) {
      * @see RxJava Wiki: sumDoubles()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumDoubles(Observable source) {
+    public static Observable sumDouble(Observable source) {
         return OperationSum.sumDoubles(source);
     }
 
@@ -4491,6 +4496,11 @@ public Observable sumDouble(Func1 valueExtractor) {
      * @see RxJava Wiki: average()
      * @see MSDN: Observable.Average
      */
+    public static Observable averageInteger(Observable source) {
+        return OperationAverage.average(source);
+    }
+    
+    @Deprecated
     public static Observable average(Observable source) {
         return OperationAverage.average(source);
     }
@@ -4507,7 +4517,7 @@ public static Observable average(Observable source) {
      * @see RxJava Wiki: averageLongs()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageLongs(Observable source) {
+    public static Observable averageLong(Observable source) {
         return OperationAverage.averageLongs(source);
     }
 
@@ -4523,7 +4533,7 @@ public static Observable averageLongs(Observable source) {
      * @see RxJava Wiki: averageFloats()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageFloats(Observable source) {
+    public static Observable averageFloat(Observable source) {
         return OperationAverage.averageFloats(source);
     }
 
@@ -4539,7 +4549,7 @@ public static Observable averageFloats(Observable source) {
      * @see RxJava Wiki: averageDoubles()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageDoubles(Observable source) {
+    public static Observable averageDouble(Observable source) {
         return OperationAverage.averageDoubles(source);
     }
 

From 9dc3f22ca4a68325b039b51300e2d475bbb93f02 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Sat, 28 Dec 2013 19:03:16 -0800
Subject: [PATCH 155/441] adjust javadocs for new sumFoo()/averageFoo() method
 names

---
 rxjava-core/src/main/java/rx/Observable.java | 32 ++++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index bf6c0b0e7d..ebf9362123 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4389,7 +4389,7 @@ public Integer call(Integer t1, T t2) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Integers emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: sum()
+     * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumInteger(Observable source) {
@@ -4410,7 +4410,7 @@ public static Observable sum(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Longs emitted by the
      *         source Observable as its single item
-     * @see RxJava Wiki: sumLongs()
+     * @see RxJava Wiki: sumLong()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumLong(Observable source) {
@@ -4426,7 +4426,7 @@ public static Observable sumLong(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Floats emitted by the
      *         source Observable as its single item
-     * @see RxJava Wiki: sumFloats()
+     * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumFloat(Observable source) {
@@ -4442,7 +4442,7 @@ public static Observable sumFloat(Observable source) {
      * @param source source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Doubles emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: sumDoubles()
+     * @see RxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
     public static Observable sumDouble(Observable source) {
@@ -4461,7 +4461,7 @@ public static Observable sumDouble(Observable source) {
      * @return an Observable that emits the integer sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
-     * @see RxJava Wiki: sumInteger()
+     * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
     public Observable sumInteger(Func1 valueExtractor) {
@@ -4480,7 +4480,7 @@ public Observable sumInteger(Func1 valueExtractor)
      * @return an Observable that emits the long sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
-     * @see RxJava Wiki: sumLong()
+     * @see RxJava Wiki: sumLong()
      * @see MSDN: Observable.Sum
      */
     public Observable sumLong(Func1 valueExtractor) {
@@ -4499,7 +4499,7 @@ public Observable sumLong(Func1 valueExtractor) {
      * @return an Observable that emits the float sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
-     * @see RxJava Wiki: sumFloat()
+     * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
     public Observable sumFloat(Func1 valueExtractor) {
@@ -4518,7 +4518,7 @@ public Observable sumFloat(Func1 valueExtractor) {
      * @return an Observable that emits the double sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
-     * @see RxJava Wiki: sumDouble()
+     * @see RxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
     public Observable sumDouble(Func1 valueExtractor) {
@@ -4535,7 +4535,7 @@ public Observable sumDouble(Func1 valueExtractor) {
      * @return an Observable that emits the average of all the Integers emitted
      *         by the source Observable as its single item
      * @throws IllegalArgumentException if the source Observable emits no items
-     * @see RxJava Wiki: average()
+     * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
     public static Observable averageInteger(Observable source) {
@@ -4556,7 +4556,7 @@ public static Observable average(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Longs emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: averageLongs()
+     * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
     public static Observable averageLong(Observable source) {
@@ -4572,7 +4572,7 @@ public static Observable averageLong(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Floats emitted by
      *         the source Observable as its single item
-     * @see RxJava Wiki: averageFloats()
+     * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
     public static Observable averageFloat(Observable source) {
@@ -4588,7 +4588,7 @@ public static Observable averageFloat(Observable source) {
      * @param source source Observable to compute the average of
      * @return an Observable that emits the average of all the Doubles emitted
      *         by the source Observable as its single item
-     * @see RxJava Wiki: averageDoubles()
+     * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
     public static Observable averageDouble(Observable source) {
@@ -4607,7 +4607,7 @@ public static Observable averageDouble(Observable source) {
      * @return an Observable that emits the integer average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into integers by the specified function
-     * @see RxJava Wiki: averageInteger()
+     * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
     public Observable averageInteger(Func1 valueExtractor) {
@@ -4626,7 +4626,7 @@ public Observable averageInteger(Func1 valueExtract
      * @return an Observable that emits the long average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into longs by the specified function
-     * @see RxJava Wiki: averageLong()
+     * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
     public Observable averageLong(Func1 valueExtractor) {
@@ -4645,7 +4645,7 @@ public Observable averageLong(Func1 valueExtractor) {
      * @return an Observable that emits the float average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into floats by the specified function
-     * @see RxJava Wiki: averageFloat()
+     * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
     public Observable averageFloat(Func1 valueExtractor) {
@@ -4664,7 +4664,7 @@ public Observable averageFloat(Func1 valueExtractor) {
      * @return an Observable that emits the double average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into doubles by the specified function
-     * @see RxJava Wiki: averageDouble()
+     * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
     public Observable averageDouble(Func1 valueExtractor) {

From cf33aad9595a26d08654a6ce89559c4a69c5ca94 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 27 Dec 2013 10:55:38 -0800
Subject: [PATCH 156/441] New contrib module: rxjava-async-util
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Home for async utility functions with juc.Future, Actions, Functions etc that don’t need to be in rxjava-core.

As per discussions at:

- https://github.com/Netflix/RxJava/pull/646#issuecomment-31147005
- https://github.com/Netflix/RxJava/pull/645#issuecomment-31146492
- https://github.com/Netflix/RxJava/pull/622#issuecomment-31144128
---
 rxjava-contrib/rxjava-async-util/build.gradle |  20 +
 .../src/main/java/rx/util/async}/Async.java   | 712 +++++++++++-------
 .../test/java/rx/util/async}/AsyncTest.java   | 315 ++++++--
 rxjava-core/src/main/java/rx/Observable.java  |  42 --
 .../src/test/java/rx/ObservableTests.java     | 123 ---
 settings.gradle                               |   3 +-
 6 files changed, 708 insertions(+), 507 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-async-util/build.gradle
 rename {rxjava-core/src/main/java/rx/util/functions => rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async}/Async.java (75%)
 rename {rxjava-core/src/test/java/rx/util/functions => rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async}/AsyncTest.java (84%)

diff --git a/rxjava-contrib/rxjava-async-util/build.gradle b/rxjava-contrib/rxjava-async-util/build.gradle
new file mode 100644
index 0000000000..09d9aae655
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/build.gradle
@@ -0,0 +1,20 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    testCompile project(":rxjava-core").sourceSets.test.output 
+    provided 'junit:junit-dep:4.10'
+    provided 'org.mockito:mockito-core:1.8.5'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-async-util'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
similarity index 75%
rename from rxjava-core/src/main/java/rx/util/functions/Async.java
rename to rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index 51a1787715..5505d9a91e 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -1,374 +1,482 @@
- /**
-  * 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.util.functions;
+/**
+ * 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.util.async;
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.schedulers.ExecutorScheduler;
 import rx.schedulers.Schedulers;
 import rx.subjects.AsyncSubject;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Action2;
+import rx.util.functions.Action3;
+import rx.util.functions.Action4;
+import rx.util.functions.Action5;
+import rx.util.functions.Action6;
+import rx.util.functions.Action7;
+import rx.util.functions.Action8;
+import rx.util.functions.Action9;
+import rx.util.functions.ActionN;
+import rx.util.functions.Actions;
+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;
 
 /**
  * Utility methods to convert functions and actions into asynchronous
  * operations through the Observable/Observer pattern.
  */
 public final class Async {
-    private Async() { throw new IllegalStateException("No instances!"); }
+    private Async() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
-     * {@link Scheduler} intended for asynchronous conversions.
+     * Invokes the specified function asynchronously and returns an Observable
+     * that emits the result.
+     * 
    
+     * Note: The function is called immediately and once, not whenever an
+     * observer subscribes to the resulting Observable. Multiple subscriptions
+     * to this Observable observe the same return value.
      * 
    
-     * Defaults to {@link #threadPoolForComputation()}.
-     *
-     * @return {@link ExecutorScheduler} for asynchronous conversion work.
+     * 
+     * 
+     * @param func
+     *            function to run asynchronously
+     * @return an Observable that emits the function's result value, or notifies
+     *         observers of an exception
+     * @see RxJava Wiki: start()
+     * @see MSDN: Observable.Start
      */
-    public static Scheduler threadPoolForAsyncConversions() {
-        return Schedulers.threadPoolForComputation();
+    public static  Observable start(Func0 func) {
+        return Async.toAsync(func).call();
     }
+
+    /**
+     * Invokes the specified function asynchronously on the specified scheduler
+     * and returns an Observable that emits the result.
+     * 
    
+     * Note: The function is called immediately and once, not whenever an
+     * observer subscribes to the resulting Observable. Multiple subscriptions
+     * to this Observable observe the same return value.
+     * 
    
+     * 
+     * 
+     * @param func
+     *            function to run asynchronously
+     * @param scheduler
+     *            scheduler to run the function on
+     * @return an Observable that emits the function's result value, or notifies
+     *         observers of an exception
+     * @see RxJava Wiki: start()
+     * @see MSDN: Observable.Start
+     */
+    public static  Observable start(Func0 func, Scheduler scheduler) {
+        return Async.toAsync(func, scheduler).call();
+    }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(Action0 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(Func0 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Action1 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Func1 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Action2 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Func2 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Action3 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Func3 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
-    public static  Func4> toAsync(Action4 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+    public static  Func4> toAsync(Action4 action) {
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(Func4 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Action5 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Func5 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Action6 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Func6 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Action7 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Func7 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Action8 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Func8 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Action9 action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Func9 func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      */
     public static FuncN> toAsync(ActionN action) {
-        return toAsync(action, threadPoolForAsyncConversions());
+        return toAsync(action, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      */
     public static  FuncN> toAsync(FuncN func) {
-        return toAsync(func, threadPoolForAsyncConversions());
+        return toAsync(func, Schedulers.threadPoolForComputation());
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(final Action0 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(final Func0 func, final Scheduler scheduler) {
@@ -394,31 +502,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Action1 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Func1 func, final Scheduler scheduler) {
@@ -444,31 +558,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Action2 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Func2 func, final Scheduler scheduler) {
@@ -494,31 +614,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Action3 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Func3 func, final Scheduler scheduler) {
@@ -536,7 +662,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -544,31 +670,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Action4 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Func4 func, final Scheduler scheduler) {
@@ -586,7 +718,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -594,31 +726,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Action5 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Func5 func, final Scheduler scheduler) {
@@ -636,7 +774,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -644,31 +782,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Action6 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Func6 func, final Scheduler scheduler) {
@@ -686,7 +830,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -694,31 +838,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Action7 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Func7 func, final Scheduler scheduler) {
@@ -736,7 +886,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -744,31 +894,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Action8 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Func8 func, final Scheduler scheduler) {
@@ -786,7 +942,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -794,31 +950,37 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Action9 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Func9 func, final Scheduler scheduler) {
@@ -836,7 +998,7 @@ public void call() {
                             subject.onError(t);
                             return;
                         }
-                        subject.onNext(result); 
+                        subject.onNext(result);
                         subject.onCompleted();
                     }
                 });
@@ -844,30 +1006,36 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * 
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      */
     public static FuncN> toAsync(final ActionN action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
-     *
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * 
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      */
     public static  FuncN> toAsync(final FuncN func, final Scheduler scheduler) {
         return new FuncN>() {
@@ -892,64 +1060,74 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
      * 
    
      * Alias for toAsync(ActionN) intended for dynamic languages.
      * 
-     * @param action the action to convert
-     *
+     * @param action
+     *            the action to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      */
     public static FuncN> asyncAction(final ActionN action) {
         return toAsync(action);
     }
+
     /**
      * Convert a synchronous action call into an asynchronous function
      * call through an Observable sequence.
      * 
    
      * Alias for toAsync(ActionN, Scheduler) intended for dynamic languages.
      * 
-     * @param action the action to convert
-     * @param scheduler the scheduler used to execute the {@code action}
-     *
+     * @param action
+     *            the action to convert
+     * @param scheduler
+     *            the scheduler used to execute the {@code action}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code action} and emits {@code null}.
-     *
+     * 
      */
     public static FuncN> asyncAction(final ActionN action, final Scheduler scheduler) {
         return toAsync(action, scheduler);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
      * 
    
      * Alias for toAsync(FuncN) intended for dynamic languages.
      * 
-     * @param func the function to convert
-     *
+     * @param func
+     *            the function to convert
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      */
     public static  FuncN> asyncFunc(final FuncN func) {
         return toAsync(func);
     }
+
     /**
      * Convert a synchronous function call into an asynchronous function
      * call through an Observable sequence.
      * 
    
      * Alias for toAsync(FuncN, Scheduler) intended for dynamic languages.
      * 
-     * @param func the function to convert
-     * @param scheduler the scheduler used to call the {@code func}
-     *
+     * @param func
+     *            the function to convert
+     * @param scheduler
+     *            the scheduler used to call the {@code func}
+     * 
      * @return a function which returns an observable sequence which
      *         executes the {@code func} and emits its returned value.
-     *
+     * 
      */
     public static  FuncN> asyncFunc(final FuncN func, final Scheduler scheduler) {
         return toAsync(func, scheduler);
diff --git a/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
similarity index 84%
rename from rxjava-core/src/test/java/rx/util/functions/AsyncTest.java
rename to rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
index 05a75c4f85..943e8ff898 100644
--- a/rxjava-core/src/test/java/rx/util/functions/AsyncTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
@@ -14,20 +14,29 @@
  * limitations under the License.
  */
 
-package rx.util.functions;
+package rx.util.async;
 
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+
 import junit.framework.Assert;
+
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Matchers.any;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import rx.Observable;
 import rx.Observer;
 import rx.schedulers.Schedulers;
+import rx.schedulers.TestScheduler;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
@@ -54,10 +63,12 @@
 public class AsyncTest {
     @Mock
     Observer observer;
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     @Test
     public void testAction0() {
         final AtomicInteger value = new AtomicInteger();
@@ -67,17 +78,18 @@ public void call() {
                 value.incrementAndGet();
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call()
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(1, value.get());
     }
+
     @Test
     public void testAction0Error() {
         Action0 action = new Action0() {
@@ -86,15 +98,16 @@ public void call() {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call()
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction1() {
         final AtomicInteger value = new AtomicInteger();
@@ -104,17 +117,18 @@ public void call(Integer t1) {
                 value.set(t1);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(1, value.get());
     }
+
     @Test
     public void testAction1Error() {
         Action1 action = new Action1() {
@@ -123,15 +137,16 @@ public void call(Integer t1) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction2() {
         final AtomicInteger value = new AtomicInteger();
@@ -141,17 +156,18 @@ public void call(Integer t1, Integer t2) {
                 value.set(t1 | t2);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(3, value.get());
     }
+
     @Test
     public void testAction2Error() {
         Action2 action = new Action2() {
@@ -160,15 +176,16 @@ public void call(Integer t1, Integer t2) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction3() {
         final AtomicInteger value = new AtomicInteger();
@@ -178,17 +195,18 @@ public void call(Integer t1, Integer t2, Integer t3) {
                 value.set(t1 | t2 | t3);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(7, value.get());
     }
+
     @Test
     public void testAction3Error() {
         Action3 action = new Action3() {
@@ -197,15 +215,16 @@ public void call(Integer t1, Integer t2, Integer t3) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction4() {
         final AtomicInteger value = new AtomicInteger();
@@ -215,17 +234,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4) {
                 value.set(t1 | t2 | t3 | t4);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(15, value.get());
     }
+
     @Test
     public void testAction4Error() {
         Action4 action = new Action4() {
@@ -234,15 +254,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction5() {
         final AtomicInteger value = new AtomicInteger();
@@ -252,17 +273,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
                 value.set(t1 | t2 | t3 | t4 | t5);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(31, value.get());
     }
+
     @Test
     public void testAction5Error() {
         Action5 action = new Action5() {
@@ -271,15 +293,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction6() {
         final AtomicInteger value = new AtomicInteger();
@@ -289,17 +312,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 value.set(t1 | t2 | t3 | t4 | t5 | t6);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(63, value.get());
     }
+
     @Test
     public void testAction6Error() {
         Action6 action = new Action6() {
@@ -308,15 +332,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction7() {
         final AtomicInteger value = new AtomicInteger();
@@ -326,17 +351,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(127, value.get());
     }
+
     @Test
     public void testAction7Error() {
         Action7 action = new Action7() {
@@ -345,15 +371,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction8() {
         final AtomicInteger value = new AtomicInteger();
@@ -363,17 +390,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(255, value.get());
     }
+
     @Test
     public void testAction8Error() {
         Action8 action = new Action8() {
@@ -382,15 +410,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testAction9() {
         final AtomicInteger value = new AtomicInteger();
@@ -400,17 +429,18 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8 | t9);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(511, value.get());
     }
+
     @Test
     public void testAction9Error() {
         Action9 action = new Action9() {
@@ -419,15 +449,16 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testActionN() {
         final AtomicInteger value = new AtomicInteger();
@@ -436,22 +467,23 @@ public void testActionN() {
             public void call(Object... args) {
                 int i = 0;
                 for (Object o : args) {
-                    i = i | (Integer)o;
+                    i = i | (Integer) o;
                 }
                 value.set(i);
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(null);
         verify(observer, times(1)).onCompleted();
-        
+
         Assert.assertEquals(1023, value.get());
     }
+
     @Test
     public void testActionNError() {
         ActionN action = new ActionN() {
@@ -460,15 +492,16 @@ public void call(Object... args) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Async.toAsync(action, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
                 .subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(null);
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void testFunc0() {
         Func0 func = new Func0() {
@@ -480,12 +513,13 @@ public Integer call() {
         Async.toAsync(func, Schedulers.immediate())
                 .call()
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(0);
         verify(observer, times(1)).onCompleted();
-        
+
     }
+
     @Test
     public void testFunc1() {
         Func1 func = new Func1() {
@@ -497,11 +531,12 @@ public Integer call(Integer t1) {
         Async.toAsync(func, Schedulers.immediate())
                 .call(1)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(1);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc2() {
         Func2 func = new Func2() {
@@ -513,11 +548,12 @@ public Integer call(Integer t1, Integer t2) {
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(3);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc3() {
         Func3 func = new Func3() {
@@ -529,11 +565,12 @@ public Integer call(Integer t1, Integer t2, Integer t3) {
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(7);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc4() {
         Func4 func = new Func4() {
@@ -545,11 +582,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4) {
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(15);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc5() {
         Func5 func = new Func5() {
@@ -561,11 +599,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5)
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(31);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc6() {
         Func6 func = new Func6() {
@@ -577,11 +616,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5,
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(63);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc7() {
         Func7 func = new Func7() {
@@ -593,11 +633,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5,
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(127);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc8() {
         Func8 func = new Func8() {
@@ -609,11 +650,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5,
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(255);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFunc9() {
         Func9 func = new Func9() {
@@ -625,11 +667,12 @@ public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5,
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(511);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void testFuncN() {
         FuncN func = new FuncN() {
@@ -637,7 +680,7 @@ public void testFuncN() {
             public Integer call(Object... args) {
                 int i = 0;
                 for (Object o : args) {
-                    i = i | (Integer)o;
+                    i = i | (Integer) o;
                 }
                 return i;
             }
@@ -645,9 +688,133 @@ public Integer call(Object... args) {
         Async.toAsync(func, Schedulers.immediate())
                 .call(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
                 .subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(1023);
         verify(observer, times(1)).onCompleted();
     }
+
+    @Test
+    public void testStartWithFunc() {
+        Func0 func = new Func0() {
+            @Override
+            public String call() {
+                return "one";
+            }
+        };
+        assertEquals("one", Async.start(func).toBlockingObservable().single());
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void testStartWithFuncError() {
+        Func0 func = new Func0() {
+            @Override
+            public String call() {
+                throw new RuntimeException("Some error");
+            }
+        };
+        Async.start(func).toBlockingObservable().single();
+    }
+
+    @Test
+    public void testStartWhenSubscribeRunBeforeFunc() {
+        TestScheduler scheduler = new TestScheduler();
+
+        Func0 func = new Func0() {
+            @Override
+            public String call() {
+                return "one";
+            }
+        };
+
+        Observable observable = Async.start(func, scheduler);
+
+        @SuppressWarnings("unchecked")
+        Observer observer = mock(Observer.class);
+        observable.subscribe(observer);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verifyNoMoreInteractions();
+
+        // Run func
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+
+        inOrder.verify(observer, times(1)).onNext("one");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testStartWhenSubscribeRunAfterFunc() {
+        TestScheduler scheduler = new TestScheduler();
+
+        Func0 func = new Func0() {
+            @Override
+            public String call() {
+                return "one";
+            }
+        };
+
+        Observable observable = Async.start(func, scheduler);
+
+        // Run func
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+
+        @SuppressWarnings("unchecked")
+        Observer observer = mock(Observer.class);
+        observable.subscribe(observer);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext("one");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testStartWithFuncAndMultipleObservers() {
+        TestScheduler scheduler = new TestScheduler();
+
+        @SuppressWarnings("unchecked")
+        Func0 func = (Func0) mock(Func0.class);
+        doAnswer(new Answer() {
+            @Override
+            public String answer(InvocationOnMock invocation) throws Throwable {
+                return "one";
+            }
+        }).when(func).call();
+
+        Observable observable = Async.start(func, scheduler);
+
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+
+        @SuppressWarnings("unchecked")
+        Observer observer1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
+        Observer observer2 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
+        Observer observer3 = mock(Observer.class);
+
+        observable.subscribe(observer1);
+        observable.subscribe(observer2);
+        observable.subscribe(observer3);
+
+        InOrder inOrder;
+        inOrder = inOrder(observer1);
+        inOrder.verify(observer1, times(1)).onNext("one");
+        inOrder.verify(observer1, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+
+        inOrder = inOrder(observer2);
+        inOrder.verify(observer2, times(1)).onNext("one");
+        inOrder.verify(observer2, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+
+        inOrder = inOrder(observer3);
+        inOrder.verify(observer3, times(1)).onNext("one");
+        inOrder.verify(observer3, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+
+        verify(func, times(1)).call();
+    }
+
 }
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index ebf9362123..e311414af8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -125,7 +125,6 @@
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
-import rx.util.functions.Async;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
@@ -7711,45 +7710,4 @@ public  Observable> gro
         return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector));
     }
 
-    /**
-     * Invokes the specified function asynchronously and returns an Observable
-     * that emits the result.
-     * 
    
-     * Note: The function is called immediately and once, not whenever an
-     * observer subscribes to the resulting Observable. Multiple subscriptions
-     * to this Observable observe the same return value.
-     * 
    
-     * 
-     * 
-     * @param func function to run asynchronously
-     * @return an Observable that emits the function's result value, or notifies
-     *         observers of an exception
-     * @see RxJava Wiki: start()
-     * @see MSDN: Observable.Start
-     */
-    public static  Observable start(Func0 func) {
-        return Async.toAsync(func).call();
-    }
-
-    /**
-     * Invokes the specified function asynchronously on the specified scheduler
-     * and returns an Observable that emits the result.
-     * 
    
-     * Note: The function is called immediately and once, not whenever an
-     * observer subscribes to the resulting Observable. Multiple subscriptions
-     * to this Observable observe the same return value.
-     * 
    
-     * 
-     * 
-     * @param func function to run asynchronously
-     * @param scheduler scheduler to run the function on
-     * @return an Observable that emits the function's result value, or notifies
-     *         observers of an exception
-     * @see RxJava Wiki: start()
-     * @see MSDN: Observable.Start
-     */
-    public static  Observable start(Func0 func, Scheduler scheduler) {
-        return Async.toAsync(func, scheduler).call();
-    }
-
 }
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index 22e0f9cd60..fb3b95e7db 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -969,129 +969,6 @@ public void testRangeWithScheduler() {
         inOrder.verify(aObserver, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-
-    @Test
-    public void testStartWithFunc() {
-        Func0 func = new Func0() {
-            @Override
-            public String call() {
-                return "one";
-            }
-        };
-        assertEquals("one", Observable.start(func).toBlockingObservable().single());
-    }
-
-    @Test(expected = RuntimeException.class)
-    public void testStartWithFuncError() {
-        Func0 func = new Func0() {
-            @Override
-            public String call() {
-                throw new RuntimeException("Some error");
-            }
-        };
-        Observable.start(func).toBlockingObservable().single();
-    }
-
-    @Test
-    public void testStartWhenSubscribeRunBeforeFunc() {
-        TestScheduler scheduler = new TestScheduler();
-
-        Func0 func = new Func0() {
-            @Override
-            public String call() {
-                return "one";
-            }
-        };
-
-        Observable observable = Observable.start(func, scheduler);
-
-        @SuppressWarnings("unchecked")
-        Observer observer = mock(Observer.class);
-        observable.subscribe(observer);
-
-        InOrder inOrder = inOrder(observer);
-        inOrder.verifyNoMoreInteractions();
-
-        // Run func
-        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-
-        inOrder.verify(observer, times(1)).onNext("one");
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testStartWhenSubscribeRunAfterFunc() {
-        TestScheduler scheduler = new TestScheduler();
-
-        Func0 func = new Func0() {
-            @Override
-            public String call() {
-                return "one";
-            }
-        };
-
-        Observable observable = Observable.start(func, scheduler);
-
-        // Run func
-        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-
-        @SuppressWarnings("unchecked")
-        Observer observer = mock(Observer.class);
-        observable.subscribe(observer);
-
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext("one");
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testStartWithFuncAndMultipleObservers() {
-        TestScheduler scheduler = new TestScheduler();
-
-        @SuppressWarnings("unchecked")
-        Func0 func = (Func0) mock(Func0.class);
-        doAnswer(new Answer() {
-            @Override
-            public String answer(InvocationOnMock invocation) throws Throwable {
-                return "one";
-            }
-        }).when(func).call();
-
-        Observable observable = Observable.start(func, scheduler);
-
-        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-
-        @SuppressWarnings("unchecked")
-        Observer observer1 = mock(Observer.class);
-        @SuppressWarnings("unchecked")
-        Observer observer2 = mock(Observer.class);
-        @SuppressWarnings("unchecked")
-        Observer observer3 = mock(Observer.class);
-
-        observable.subscribe(observer1);
-        observable.subscribe(observer2);
-        observable.subscribe(observer3);
-
-        InOrder inOrder;
-        inOrder = inOrder(observer1);
-        inOrder.verify(observer1, times(1)).onNext("one");
-        inOrder.verify(observer1, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-
-        inOrder = inOrder(observer2);
-        inOrder.verify(observer2, times(1)).onNext("one");
-        inOrder.verify(observer2, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-
-        inOrder = inOrder(observer3);
-        inOrder.verify(observer3, times(1)).onNext("one");
-        inOrder.verify(observer3, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-
-        verify(func, times(1)).call();
-    }
     
     @Test
     public void testCollectToList() {
diff --git a/settings.gradle b/settings.gradle
index 176e9150c5..c40f29adb6 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -8,4 +8,5 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-swing', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \
-'rxjava-contrib:rxjava-string'
+'rxjava-contrib:rxjava-string', \
+'rxjava-contrib:rxjava-async-util'

From a87489a7bef03a7293aa6fc4207d3dfc0bda2007 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 28 Dec 2013 01:54:56 +0100
Subject: [PATCH 157/441] Manual merge of
 https://github.com/akarnokd/RxJava/commit/eee312a6ac41582e4efe3daac3dfcd0385359d25

- To clean up the pull request I cherry picked the single commit with actual changes to avoid the merges that affected lots of other files.
- The original commit also included conflicting and unrelated changes to Observable and ObservableTests that I skippedManual merge of https://github.com/akarnokd/RxJava/commit/eee312a6ac41582e4efe3daac3dfcd0385359d25
---
 .../src/main/java/rx/util/async/Async.java    | 1744 +++++++++++------
 .../rx/util/async/operators/Functionals.java  |  113 ++
 .../util/async/operators/LatchedObserver.java |  304 +++
 .../async/operators/OperationDeferFuture.java |   88 +
 .../operators/OperationForEachFuture.java     |  132 ++
 .../operators/OperationFromFunctionals.java   |  114 ++
 .../async/operators/OperationStartFuture.java |   68 +
 .../operators/OperationDeferFutureTest.java   |  105 +
 .../operators/OperationForEachFutureTest.java |  170 ++
 .../OperationFromFunctionalsTest.java         |  241 +++
 .../operators/OperationStartFutureTest.java   |  147 ++
 11 files changed, 2627 insertions(+), 599 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
 create mode 100644 rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java

diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index 5505d9a91e..dbbafbd50f 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -1,25 +1,32 @@
 /**
  * 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
- * 
+ *
+ * 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.
+ * 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.util.async;
 
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
 import rx.Observable;
 import rx.Scheduler;
 import rx.schedulers.Schedulers;
 import rx.subjects.AsyncSubject;
+import rx.util.async.operators.Functionals;
+import rx.util.async.operators.OperationDeferFuture;
+import rx.util.async.operators.OperationForEachFuture;
+import rx.util.async.operators.OperationFromFunctionals;
+import rx.util.async.operators.OperationStartFuture;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
@@ -45,14 +52,15 @@
 import rx.util.functions.FuncN;
 
 /**
- * Utility methods to convert functions and actions into asynchronous
- * operations through the Observable/Observer pattern.
+ * Utility methods to convert functions and actions into asynchronous operations
+ * through the Observable/Observer pattern.
  */
 public final class Async {
+    
     private Async() {
         throw new IllegalStateException("No instances!");
     }
-
+    
     /**
      * Invokes the specified function asynchronously and returns an Observable
      * that emits the result.
@@ -61,19 +69,24 @@ private Async() {
      * observer subscribes to the resulting Observable. Multiple subscriptions
      * to this Observable observe the same return value.
      * 
    
-     * 
-     * 
-     * @param func
-     *            function to run asynchronously
+     * 
+     *
+     * @param  the result value type
+     * @param func function to run asynchronously
      * @return an Observable that emits the function's result value, or notifies
-     *         observers of an exception
-     * @see RxJava Wiki: start()
-     * @see MSDN: Observable.Start
+     * observers of an exception
+     * @see RxJava
+     * Wiki: start()
+     * @see MSDN:
+     * Observable.Start
      */
     public static  Observable start(Func0 func) {
         return Async.toAsync(func).call();
     }
-
+    
     /**
      * Invokes the specified function asynchronously on the specified scheduler
      * and returns an Observable that emits the result.
@@ -82,402 +95,526 @@ public static  Observable start(Func0 func) {
      * observer subscribes to the resulting Observable. Multiple subscriptions
      * to this Observable observe the same return value.
      * 
    
-     * 
-     * 
-     * @param func
-     *            function to run asynchronously
-     * @param scheduler
-     *            scheduler to run the function on
+     * 
+     *
+     * @param  the result value type
+     * @param func function to run asynchronously
+     * @param scheduler scheduler to run the function on
      * @return an Observable that emits the function's result value, or notifies
-     *         observers of an exception
-     * @see RxJava Wiki: start()
-     * @see MSDN: Observable.Start
+     * observers of an exception
+     * @see RxJava
+     * Wiki: start()
+     * @see MSDN:
+     * Observable.Start
      */
     public static  Observable start(Func0 func, Scheduler scheduler) {
         return Async.toAsync(func, scheduler).call();
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static Func0> toAsync(Action0 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the result value type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func0> toAsync(Func0 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  first parameter type of the action
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func1> toAsync(Action1 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  first parameter type of the action
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func1> toAsync(Func1 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func2> toAsync(Action2 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func2> toAsync(Func2 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func3> toAsync(Action3 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func3> toAsync(Func3 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func4> toAsync(Action4 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func4> toAsync(Func4 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func5> toAsync(Action5 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func5> toAsync(Func5 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func6> toAsync(Action6 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func6> toAsync(Func6 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func7> toAsync(Action7 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func7> toAsync(Func7 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func8> toAsync(Action8 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func8> toAsync(Func8 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the ninth parameter type
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func9> toAsync(Action9 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the ninth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func9> toAsync(Func9 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
      */
     public static FuncN> toAsync(ActionN action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
      */
     public static  FuncN> toAsync(FuncN func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static Func0> toAsync(final Action0 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func0> toAsync(final Func0 func, final Scheduler scheduler) {
         return new Func0>() {
@@ -502,38 +639,41 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func1> toAsync(final Action1 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func1> toAsync(final Func1 func, final Scheduler scheduler) {
         return new Func1>() {
@@ -558,38 +698,43 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func2> toAsync(final Action2 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func2> toAsync(final Func2 func, final Scheduler scheduler) {
         return new Func2>() {
@@ -614,38 +759,45 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func3> toAsync(final Action3 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func3> toAsync(final Func3 func, final Scheduler scheduler) {
         return new Func3>() {
@@ -670,38 +822,47 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func4> toAsync(final Action4 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func4> toAsync(final Func4 func, final Scheduler scheduler) {
         return new Func4>() {
@@ -726,38 +887,49 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func5> toAsync(final Action5 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func5> toAsync(final Func5 func, final Scheduler scheduler) {
         return new Func5>() {
@@ -782,38 +954,51 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func6> toAsync(final Action6 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func6> toAsync(final Func6 func, final Scheduler scheduler) {
         return new Func6>() {
@@ -838,38 +1023,53 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func7> toAsync(final Action7 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func7> toAsync(final Func7 func, final Scheduler scheduler) {
         return new Func7>() {
@@ -894,38 +1094,55 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func8> toAsync(final Action8 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func8> toAsync(final Func8 func, final Scheduler scheduler) {
         return new Func8>() {
@@ -950,38 +1167,57 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the ninth parameter type
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func9> toAsync(final Action9 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
-     * @see MSDN: Observable.ToAsync
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the first parameter type
+     * @param  the second parameter type
+     * @param  the third parameter type
+     * @param  the fourth parameter type
+     * @param  the fifth parameter type
+     * @param  the sixth parameter type
+     * @param  the seventh parameter type
+     * @param  the eighth parameter type
+     * @param  the ninth parameter type
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
+     * @see MSDN:
+     * Observable.ToAsync
      */
     public static  Func9> toAsync(final Func9 func, final Scheduler scheduler) {
         return new Func9>() {
@@ -1006,36 +1242,33 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
      */
     public static FuncN> toAsync(final ActionN action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
+     *
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
      */
     public static  FuncN> toAsync(final FuncN func, final Scheduler scheduler) {
         return new FuncN>() {
@@ -1060,76 +1293,389 @@ public void call() {
             }
         };
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
      * 
    
      * Alias for toAsync(ActionN) intended for dynamic languages.
-     * 
-     * @param action
-     *            the action to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
+     *
+     * @param action the action to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
      */
     public static FuncN> asyncAction(final ActionN action) {
         return toAsync(action);
     }
-
+    
     /**
-     * Convert a synchronous action call into an asynchronous function
-     * call through an Observable sequence.
+     * Convert a synchronous action call into an asynchronous function call
+     * through an Observable sequence.
      * 
    
      * Alias for toAsync(ActionN, Scheduler) intended for dynamic languages.
-     * 
-     * @param action
-     *            the action to convert
-     * @param scheduler
-     *            the scheduler used to execute the {@code action}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code action} and emits {@code null}.
-     * 
+     *
+     * @param action the action to convert
+     * @param scheduler the scheduler used to execute the {@code action}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code action} and emits {@code null}.
+     *
      */
     public static FuncN> asyncAction(final ActionN action, final Scheduler scheduler) {
         return toAsync(action, scheduler);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
      * 
    
      * Alias for toAsync(FuncN) intended for dynamic languages.
-     * 
-     * @param func
-     *            the function to convert
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
+     *
+     * @param  the result type
+     * @param func the function to convert
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
      */
     public static  FuncN> asyncFunc(final FuncN func) {
         return toAsync(func);
     }
-
+    
     /**
-     * Convert a synchronous function call into an asynchronous function
-     * call through an Observable sequence.
+     * Convert a synchronous function call into an asynchronous function call
+     * through an Observable sequence.
      * 
    
      * Alias for toAsync(FuncN, Scheduler) intended for dynamic languages.
-     * 
-     * @param func
-     *            the function to convert
-     * @param scheduler
-     *            the scheduler used to call the {@code func}
-     * 
-     * @return a function which returns an observable sequence which
-     *         executes the {@code func} and emits its returned value.
-     * 
+     *
+     * @param  the result type
+     * @param func the function to convert
+     * @param scheduler the scheduler used to call the {@code func}
+     *
+     * @return a function which returns an observable sequence which executes
+     * the {@code func} and emits its returned value.
+     *
      */
     public static  FuncN> asyncFunc(final FuncN func, final Scheduler scheduler) {
         return toAsync(func, scheduler);
     }
+    
+    /**
+     * Invokes the asynchronous function immediately, surfacing the result
+     * through an observable sequence.
+     * 
    
+     * Important note subscribing to the resulting observable blocks
+     * until the future completes.
+     *
+     * @param  the result type
+     * @param functionAsync the asynchronous function to run
+     * @return an observable which surfaces the result of the future.
+     * @see #startFuture(rx.util.functions.Func0, rx.Scheduler)
+     */
+    public static  Observable startFuture(Func0> functionAsync) {
+        return OperationStartFuture.startFuture(functionAsync);
+    }
+    
+    /**
+     * Invokes the asynchronous function immediately, surfacing the result
+     * through an observable sequence and waits on the specified scheduler.
+     *
+     * @param  the result type
+     * @param functionAsync the asynchronous function to run
+     * @param scheduler the scheduler where the completion of the Future is
+     * awaited
+     * @return an observable which surfaces the result of the future.
+     */
+    public static  Observable startFuture(Func0> functionAsync,
+        Scheduler scheduler) {
+        return OperationStartFuture.startFuture(functionAsync, scheduler);
+    }
+    
+    /**
+     * Returns an observable sequence that starts the specified asynchronous
+     * factory function whenever a new observer subscribes.
+     * 
    
+     * Important note subscribing to the resulting observable blocks
+     * until the future completes.
+     *
+     * @param  the result type
+     * @param observableFactoryAsync the asynchronous function to start for each
+     * observer
+     * @return the observable sequence containing values produced by the
+     * asynchronous observer produced by the factory
+     * @see #deferFuture(rx.util.functions.Func0, rx.Scheduler)
+     */
+    public static  Observable deferFuture(Func0>> observableFactoryAsync) {
+        return OperationDeferFuture.deferFuture(observableFactoryAsync);
+    }
+    
+    /**
+     * Returns an observable sequence that starts the specified asynchronous
+     * factory function whenever a new observer subscribes.
+     *
+     * @param  the result type
+     * @param observableFactoryAsync the asynchronous function to start for each
+     * observer
+     * @param scheduler the scheduler where the completion of the Future is
+     * awaited
+     * @return the observable sequence containing values produced by the
+     * asynchronous observer produced by the factory
+     */
+    public static  Observable deferFuture(
+        Func0>> observableFactoryAsync,
+        Scheduler scheduler) {
+        return OperationDeferFuture.deferFuture(observableFactoryAsync, scheduler);
+    }
+    
+    /**
+     * Subscribes to the given source and calls the callback for each
+     * emitted item, and surfaces the completion or error through a Future.
+     * 
    
+     * Important note: The returned task blocks indefinitely unless
+     * the run() method is called or the task is scheduled on an Executor.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @return the Future representing the entire for-each operation
+     * @see #forEachFuture(rx.util.functions.Action1, rx.Scheduler)
+     */
+    public static  FutureTask forEachFuture(
+        Observable source,
+        Action1 onNext) {
+        return OperationForEachFuture.forEachFuture(source, onNext);
+    }
+    
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future.
+     * 
    
+     * Important note: The returned task blocks indefinitely unless
+     * the run() method is called or the task is scheduled on an Executor.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @return the Future representing the entire for-each operation
+     * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.Scheduler)
+     */
+    public static  FutureTask forEachFuture(
+        Observable source,
+        Action1 onNext,
+        Action1 onError) {
+        return OperationForEachFuture.forEachFuture(source, onNext, onError);
+    }
+    
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future.
+     * 
    
+     * Important note: The returned task blocks indefinitely unless
+     * the run() method is called or the task is scheduled on an Executor.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @param onCompleted the action to call when the source completes
+     * @return the Future representing the entire for-each operation
+     * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.util.functions.Action0, rx.Scheduler)
+     */
+    public static  FutureTask forEachFuture(
+        Observable source,
+        Action1 onNext,
+        Action1 onError,
+        Action0 onCompleted) {
+        return OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
+    }
+    
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+        Observable source,
+        Action1 onNext,
+        Scheduler scheduler) {
+        FutureTask < Void > task = OperationForEachFuture.forEachFuture(source, onNext);
+        scheduler.schedule(Functionals.fromRunnable(task));
+        return task;
+    }
+    
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+        Observable source,
+        Action1 onNext,
+        Action1 onError,
+        Scheduler scheduler) {
+        FutureTask < Void > task = OperationForEachFuture.forEachFuture(source, onNext, onError);
+        scheduler.schedule(Functionals.fromRunnable(task));
+        return task;
+    }
+    
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * @param  the source value type
+     * @param source the source Observable sequence
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @param onCompleted the action to call when the source completes
+     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+            Observable source,
+            Action1 onNext,
+            Action1 onError,
+            Action0 onCompleted,
+            Scheduler scheduler) {
+        FutureTask task = OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
+        scheduler.schedule(Functionals.fromRunnable(task));
+        return task;
+    }
+    
+    /**
+     * Return an Observable which calls the given action and emits the given
+     * result when an Observer subscribes.
+     * 
    
+     * The action is run on the default thread pool for computation.
+     * @param  the return type
+     * @param action the action to invoke on each subscription
+     * @param result the result to emit to observers
+     * @return an Observable which calls the given action and emits the given
+     * result when an Observer subscribes
+     */
+    public static  Observable fromAction(Action0 action, R result) {
+        return fromAction(action, result, Schedulers.threadPoolForComputation());
+    }
+    
+    /**
+     * Return an Observable which calls the given function and emits its
+     * result when an Observer subscribes.
+     * 
    
+     * The function is called on the default thread pool for computation.
+     * 
+     * @param  the return type
+     * @param function the function to call on each subscription
+     * @return an Observable which calls the given function and emits its
+     * result when an Observer subscribes
+     * @see #start(rx.util.functions.Func0) 
+     * @see #fromCallable(java.util.concurrent.Callable) 
+     */
+    public static  Observable fromFunc0(Func0 function) {
+        return fromFunc0(function, Schedulers.threadPoolForComputation());
+    }
+    /**
+     * Return an Observable which calls the given Callable and emits its
+     * result or Exception when an Observer subscribes.
+     * 
    
+     * The Callable is called on the default thread pool for computation.
+     * 
+     * @param  the return type
+     * @param callable the callable to call on each subscription
+     * @return an Observable which calls the given Callable and emits its
+     * result or Exception when an Observer subscribes
+     * @see #start(rx.util.functions.Func0) 
+     * @see #fromFunc0(rx.util.functions.Func0) 
+     */
+    public static  Observable fromCallable(Callable callable) {
+        return fromCallable(callable, Schedulers.threadPoolForComputation());
+    }
+    
+    /**
+     * Return an Observable which calls the given Runnable and emits the given
+     * result when an Observer subscribes.
+     * 
    
+     * The Runnable is called on the default thread pool for computation.
+     * 
+     * @param  the return type
+     * @param run the runnable to invoke on each subscription
+     * @param result the result to emit to observers
+     * @return an Observable which calls the given Runnable and emits the given
+     * result when an Observer subscribes
+     */
+    public static  Observable fromRunnable(final Runnable run, final R result) {
+        return fromRunnable(run, result, Schedulers.threadPoolForComputation());
+    }
+    
+    /**
+     * Return an Observable which calls the given action and emits the given
+     * result when an Observer subscribes.
+     * 
+     * @param  the return type
+     * @param action the action to invoke on each subscription
+     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @param result the result to emit to observers
+     * @return an Observable which calls the given action and emits the given
+     * result when an Observer subscribes
+     */
+    public static  Observable fromAction(Action0 action, R result, Scheduler scheduler) {
+        return Observable.create(OperationFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
+    }
+    
+    /**
+     * Return an Observable which calls the given function and emits its
+     * result when an Observer subscribes.
+     * 
+     * @param  the return type
+     * @param function the function to call on each subscription
+     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @return an Observable which calls the given function and emits its
+     * result when an Observer subscribes
+     * @see #start(rx.util.functions.Func0) 
+     * @see #fromCallable(java.util.concurrent.Callable) 
+     */
+    public static  Observable fromFunc0(Func0 function, Scheduler scheduler) {
+        return Observable.create(OperationFromFunctionals.fromFunc0(function)).subscribeOn(scheduler);
+    }
+    /**
+     * Return an Observable which calls the given Callable and emits its
+     * result or Exception when an Observer subscribes.
+     * 
+     * @param  the return type
+     * @param callable the callable to call on each subscription
+     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @return an Observable which calls the given Callable and emits its
+     * result or Exception when an Observer subscribes
+     * @see #start(rx.util.functions.Func0) 
+     * @see #fromFunc0(rx.util.functions.Func0) 
+     */
+    public static  Observable fromCallable(Callable callable, Scheduler scheduler) {
+        return Observable.create(OperationFromFunctionals.fromCallable(callable)).subscribeOn(scheduler);
+    }
+    
+    /**
+     * Return an Observable which calls the given Runnable and emits the given
+     * result when an Observer subscribes.
+     * 
+     * @param  the return type
+     * @param run the runnable to invoke on each subscription
+     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @param result the result to emit to observers
+     * @return an Observable which calls the given Runnable and emits the given
+     * result when an Observer subscribes
+     */
+    public static  Observable fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
+        return Observable.create(OperationFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);
+    }
 }
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
new file mode 100644
index 0000000000..1117fef941
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
@@ -0,0 +1,113 @@
+/**
+ * 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.util.async.operators;
+
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Utility methods convert between functional interfaces of actions and functions.
+ */
+public final class Functionals {
+    private Functionals() {
+        throw new IllegalStateException("No instances!");
+    }
+    /**
+     * Return an action which takes a Throwable and does nothing.
+     * 
    (To avoid casting from the generic empty1().)
+     * @return the action
+     */
+    public static Action1 emptyThrowable() {
+        return EMPTY_THROWABLE;
+    }
+    /**
+     * An action that takes a Throwable and does nothing.
+     */
+    private static final Action1 EMPTY_THROWABLE = new EmptyThrowable();
+    /** An empty throwable class. */
+    private static final class EmptyThrowable implements Action1 {
+        @Override
+        public void call(Throwable t1) {
+        }
+    }
+    /**
+     * Return an Action0 instance which does nothing.
+     * @return an Action0 instance which does nothing
+     */
+    public static Action0 empty() {
+        return EMPTY;
+    }
+    /** A single empty instance. */
+    private static final Action0 EMPTY = new EmptyAction();
+    /** An empty action class. */
+    private static final class EmptyAction implements Action0 {
+        @Override
+        public void call() {
+        }
+    }
+    
+    /**
+     * Converts a runnable instance into an Action0 instance.
+     * @param run the Runnable to run when the Action0 is called
+     * @return the Action0 wrapping the Runnable
+     */
+    public static Action0 fromRunnable(Runnable run) {
+        if (run == null) {
+            throw new NullPointerException("run");
+        }
+        return new ActionWrappingRunnable(run);
+    }
+    /** An Action0 which wraps and calls a Runnable. */
+    private static final class ActionWrappingRunnable implements Action0 {
+        final Runnable run;
+
+        public ActionWrappingRunnable(Runnable run) {
+            this.run = run;
+        }
+
+        @Override
+        public void call() {
+            run.run();
+        }
+        
+    }
+    /**
+     * Converts an Action0 instance into a Runnable instance.
+     * @param action the Action0 to call when the Runnable is run
+     * @return the Runnable wrapping the Action0
+     */
+    public static Runnable toRunnable(Action0 action) {
+        if (action == null) {
+            throw new NullPointerException("action");
+        }
+        return new RunnableAction(action);
+    }
+    /** An Action0 which wraps and calls a Runnable. */
+    private static final class RunnableAction implements Runnable {
+        final Action0 action;
+
+        public RunnableAction(Action0 action) {
+            this.action = action;
+        }
+
+        @Override
+        public void run() {
+            action.call();
+        }
+        
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
new file mode 100644
index 0000000000..dc89ad2748
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
@@ -0,0 +1,304 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import rx.Observer;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Action2;
+
+/**
+ * An observer implementation that calls a CountDownLatch in case
+ * a terminal state has been reached.
+ * @param  the observed value type
+ */
+abstract class LatchedObserver implements Observer {
+    /** The CountDownLatch to count-down on a terminal state. */
+    protected final CountDownLatch latch;
+    /** Contains the error. */
+    protected volatile Throwable error;
+    /**
+     * Indicates the completion status.
+     */
+    protected final AtomicBoolean done;
+    /**
+     * Consturcts a LatchedObserver instance.
+     * @param latch the CountDownLatch to use
+     */
+    public LatchedObserver(CountDownLatch latch) {
+        this.latch = latch;
+        this.done = new AtomicBoolean();
+    }
+    
+    /**
+     * Override this method to handle an onNext event.
+     * @param value 
+     */
+    protected abstract void onNextCore(T value);
+    /**
+     * Override this method to handle an onError event.
+     * @param e 
+     */
+    protected abstract void onErrorCore(Throwable e);
+    /**
+     * Override this to handle th onCompleted event.
+     */
+    protected abstract void onCompletedCore();
+    /**
+     * Try to move into an error state.
+     * @param e
+     * @return true if succeded, false if this observable has already terminated
+     */
+    protected boolean fail(Throwable e) {
+        if (done.compareAndSet(false, true)) {
+            onErrorCore(e);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public final void onNext(T args) {
+        if (!done.get()) {
+            onNextCore(args);
+        }
+    }
+
+    @Override
+    public final void onError(Throwable e) {
+        fail(e);
+    }
+
+    @Override
+    public final void onCompleted() {
+        if (done.compareAndSet(false, true)) {
+            onCompletedCore();
+        }
+    }
+    
+    /**
+     * Block and await the latch.
+     * @throws InterruptedException if the wait is interrupted
+     */
+    public void await() throws InterruptedException {
+        latch.await();
+    }
+    /**
+     * Block and await the latch for a given amount of time.
+     * @see CountDownLatch#await(long, java.util.concurrent.TimeUnit) 
+     */
+    public boolean await(long time, TimeUnit unit) throws InterruptedException {
+        return latch.await(time, unit);
+    }
+    /**
+     * Returns the observed error or null if there was none.
+     * 
    
+     * Should be generally called after the await() returns.
+     * @return the observed error
+     */
+    public Throwable getThrowable() {
+        return error;
+    }
+    
+    /**
+     * Create a LatchedObserver with the given callback function(s).
+     */
+    public static  LatchedObserver create(Action1 onNext) {
+        return create(onNext, new CountDownLatch(1));
+    }
+
+    /**
+     * Create a LatchedObserver with the given callback function(s).
+     */
+    public static  LatchedObserver create(Action1 onNext, Action1 onError) {
+        return create(onNext, onError, new CountDownLatch(1));
+    }
+
+    /**
+     * Create a LatchedObserver with the given callback function(s).
+     */
+    public static  LatchedObserver create(Action1 onNext, Action1 onError, Action0 onCompleted) {
+        return create(onNext, onError, onCompleted, new CountDownLatch(1));
+    }
+    
+    /**
+     * Create a LatchedObserver with the given callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver create(Action1 onNext, CountDownLatch latch) {
+        return new LatchedObserverImpl(onNext, Functionals.emptyThrowable(), Functionals.empty(), latch);
+    }
+
+    /**
+     * Create a LatchedObserver with the given callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver create(Action1 onNext, Action1 onError, CountDownLatch latch) {
+        return new LatchedObserverImpl(onNext, onError, Functionals.empty(), latch);
+    }
+
+    /**
+     * Create a LatchedObserver with the given callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver create(Action1 onNext, Action1 onError, Action0 onCompleted, CountDownLatch latch) {
+        return new LatchedObserverImpl(onNext, onError, onCompleted, latch);
+    }
+    
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s).
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext) {
+        return createIndexed(onNext, new CountDownLatch(1));
+    }
+
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s).
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext, Action1 onError) {
+        return createIndexed(onNext, onError, new CountDownLatch(1));
+    }
+
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s).
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext, Action1 onError, Action0 onCompleted) {
+        return createIndexed(onNext, onError, onCompleted, new CountDownLatch(1));
+    }
+    
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext, CountDownLatch latch) {
+        return new LatchedObserverIndexedImpl(onNext, Functionals.emptyThrowable(), Functionals.empty(), latch);
+    }
+
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext, Action1 onError, CountDownLatch latch) {
+        return new LatchedObserverIndexedImpl(onNext, onError, Functionals.empty(), latch);
+    }
+
+    /**
+     * Create a LatchedObserver with the given indexed callback function(s) and a shared latch.
+     */
+    public static  LatchedObserver createIndexed(Action2 onNext, Action1 onError, Action0 onCompleted, CountDownLatch latch) {
+        return new LatchedObserverIndexedImpl(onNext, onError, onCompleted, latch);
+    }
+
+    /**
+     * A latched observer which calls an action for each observed value
+     * and checks if a cancellation token is not unsubscribed.
+     * @param  the observed value type
+     */
+    private static final class LatchedObserverImpl extends LatchedObserver {
+        final Action1 onNext;
+        final Action1 onError;
+        final Action0 onCompleted;
+
+        public LatchedObserverImpl(Action1 onNext, 
+                Action1 onError, 
+                Action0 onCompleted, 
+                CountDownLatch latch) {
+            super(latch);
+            this.onNext = onNext;
+            this.onError = onError;
+            this.onCompleted = onCompleted;
+        }
+        
+        @Override
+        protected void onNextCore(T args) {
+            try {
+                onNext.call(args);
+            } catch (Throwable t) {
+                fail(t);
+            }
+        }
+
+        @Override
+        protected void onErrorCore(Throwable e) {
+            try {
+                error = e;
+                onError.call(e);
+            } finally {
+                latch.countDown();
+            }
+        }
+
+        @Override
+        protected void onCompletedCore() {
+            try {
+                onCompleted.call();
+            } finally {
+                latch.countDown();
+            }
+        }
+    }
+    /**
+     * A latched observer which calls an action for each observed value
+     * and checks if a cancellation token is not unsubscribed.
+     * @param  the observed value type
+     */
+    private static final class LatchedObserverIndexedImpl extends LatchedObserver {
+        final Action2 onNext;
+        final Action1 onError;
+        final Action0 onCompleted;
+        int index;
+
+        public LatchedObserverIndexedImpl(Action2 onNext, 
+                Action1 onError, 
+                Action0 onCompleted, 
+                CountDownLatch latch) {
+            super(latch);
+            this.onNext = onNext;
+            this.onError = onError;
+            this.onCompleted = onCompleted;
+        }
+        
+        @Override
+        protected void onNextCore(T args) {
+            if (index == Integer.MAX_VALUE) {
+                fail(new ArithmeticException("index overflow"));
+                return;
+            }
+            try {
+                onNext.call(args, index++);
+            } catch (Throwable t) {
+                fail(t);
+            }
+        }
+
+        @Override
+        protected void onErrorCore(Throwable e) {
+            try {
+                error = e;
+                onError.call(e);
+            } finally {
+                latch.countDown();
+            }
+        }
+
+        @Override
+        protected void onCompletedCore() {
+            try {
+                onCompleted.call();
+            } finally {
+                latch.countDown();
+            }
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
new file mode 100644
index 0000000000..fab5f2766f
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
@@ -0,0 +1,88 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.Future;
+import rx.Observable;
+import rx.Scheduler;
+import rx.util.functions.Func0;
+import rx.util.functions.Func1;
+
+/**
+ * Defer the execution of a factory method which produces an observable sequence.
+ */
+public final class OperationDeferFuture {
+    /** Utility class. */
+    private OperationDeferFuture() { throw new IllegalStateException("No instances!"); }
+    
+    /**
+     * Returns an observable sequence that starts the specified asynchronous 
+     * factory function whenever a new observer subscribes.
+     * @param  the result type
+     * @param observableFactoryAsync the asynchronous function to start for each observer
+     * @return the observable sequence containing values produced by the asynchronous observer
+     * produced by the factory
+     */
+    public static  Observable deferFuture(Func0>> observableFactoryAsync) {
+        return Observable.defer(new DeferFutureFunc0(observableFactoryAsync));
+    }
+    /** The function called by the defer operator. */
+    private static final class DeferFutureFunc0 implements Func0> {
+        final Func0>> observableFactoryAsync;
+
+        public DeferFutureFunc0(Func0>> observableFactoryAsync) {
+            this.observableFactoryAsync = observableFactoryAsync;
+        }
+        
+        @Override
+        public Observable call() {
+            return Observable.merge(OperationStartFuture.startFuture(observableFactoryAsync));
+        }
+        
+    }
+    
+    /**
+     * Returns an observable sequence that starts the specified asynchronous 
+     * factory function whenever a new observer subscribes.
+     * @param  the result type
+     * @param observableFactoryAsync the asynchronous function to start for each observer
+     * @param scheduler the scheduler where the completion of the Future is awaited
+     * @return the observable sequence containing values produced by the asynchronous observer
+     * produced by the factory
+     */
+    public static  Observable deferFuture(
+            Func0>> observableFactoryAsync,
+            Scheduler scheduler) {
+        return Observable.defer(new DeferFutureFunc0Scheduled(observableFactoryAsync, scheduler));
+    }
+    /** The function called by the defer operator. */
+    private static final class DeferFutureFunc0Scheduled implements Func0> {
+        final Func0>> observableFactoryAsync;
+        final Scheduler scheduler;
+
+        public DeferFutureFunc0Scheduled(Func0>> observableFactoryAsync,
+                Scheduler scheduler) {
+            this.observableFactoryAsync = observableFactoryAsync;
+            this.scheduler = scheduler;
+        }
+        
+        @Override
+        public Observable call() {
+            return Observable.merge(OperationStartFuture.startFuture(observableFactoryAsync, scheduler));
+        }
+        
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
new file mode 100644
index 0000000000..74a060b345
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
@@ -0,0 +1,132 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.FutureTask;
+import rx.Observable;
+import rx.Subscription;
+import rx.util.Exceptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Convert the observation of a source observable to a big Future call.
+ * 
    
+ * Remark: the cancellation token version's behavior is in doubt, so left out.
+ */
+public final class OperationForEachFuture {
+    /** Utility class. */
+    private OperationForEachFuture() { throw new IllegalStateException("No instances!"); }
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future.
+     * @param  the element type of the Observable
+     * @param source the source Observable
+     * @param onNext the action to call with each emitted element
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+            Observable source, 
+            Action1 onNext) {
+        return forEachFuture(source, onNext, Functionals.emptyThrowable(), Functionals.empty());
+    }
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future.
+     * @param  the element type of the Observable
+     * @param source the source Observable
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+            Observable source, 
+            Action1 onNext,
+            Action1 onError) {
+        return forEachFuture(source, onNext, onError, Functionals.empty());
+    }
+    
+    /**
+     * Subscribes to the given source and calls the callback for each emitted item,
+     * and surfaces the completion or error through a Future.
+     * @param  the element type of the Observable
+     * @param source the source Observable
+     * @param onNext the action to call with each emitted element
+     * @param onError the action to call when an exception is emitted
+     * @param onCompleted the action to call when the source completes
+     * @return the Future representing the entire for-each operation
+     */
+    public static  FutureTask forEachFuture(
+            Observable source, 
+            Action1 onNext,
+            Action1 onError,
+            Action0 onCompleted) {
+        
+        LatchedObserver lo = LatchedObserver.create(onNext, onError, onCompleted);
+
+        Subscription s = source.subscribe(lo);
+        
+        FutureTaskCancel task = new FutureTaskCancel(s, new RunAwait(lo));
+        
+        return task;
+    }
+    /**
+     * A future task that unsubscribes the given subscription when cancelled.
+     * @param  the return value type
+     */
+    private static final class FutureTaskCancel extends FutureTask {
+        final Subscription cancel;
+
+        public FutureTaskCancel(Subscription cancel, Callable callable) {
+            super(callable);
+            this.cancel = cancel;
+        }
+
+        public FutureTaskCancel(Subscription cancel, Runnable runnable, T result) {
+            super(runnable, result);
+            this.cancel = cancel;
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            cancel.unsubscribe();
+            return super.cancel(mayInterruptIfRunning);
+        }
+        
+    }
+    
+    /** Await the completion of a latched observer and throw its exception if any. */
+    private static final class RunAwait implements Callable {
+        final LatchedObserver observer;
+
+        public RunAwait(LatchedObserver observer) {
+            this.observer = observer;
+        }
+        
+        @Override
+        public Void call() throws Exception {
+            observer.await();
+            Throwable t = observer.getThrowable();
+            if (t != null) {
+                throw Exceptions.propagate(t);
+            }
+            return null;
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
new file mode 100644
index 0000000000..24af4e0939
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
@@ -0,0 +1,114 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.Callable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Actions;
+import rx.util.functions.Func0;
+
+/**
+ * Operators that invoke a function or action if
+ * an observer subscribes.
+ * Asynchrony can be achieved by using subscribeOn or observeOn.
+ */
+public final class OperationFromFunctionals {
+    /** Utility class. */
+    private OperationFromFunctionals() { throw new IllegalStateException("No instances!"); }
+    
+    /** Subscriber function that invokes an action and returns the given result. */
+    public static  OnSubscribeFunc fromAction(Action0 action, R result) {
+        return new InvokeAsync(Actions.toFunc(action, result));
+    }
+    
+    /** Subscriber function that invokes a function and returns its value. */
+    public static  OnSubscribeFunc fromFunc0(Func0 function) {
+        return new InvokeAsync(function);
+    }
+    
+    /** 
+     * Subscriber function that invokes the callable and returns its value or
+     * propagates its checked exception.
+     */
+    public static  OnSubscribeFunc fromCallable(Callable callable) {
+        return new InvokeAsyncCallable(callable);
+    }
+    /** Subscriber function that invokes a runnable and returns the given result. */
+    public static  OnSubscribeFunc fromRunnable(final Runnable run, final R result) {
+        return new InvokeAsync(new Func0() {
+            @Override
+            public R call() {
+                run.run();
+                return result;
+            }
+        });
+    }
+    
+    /**
+     * Invokes a function when an observer subscribes.
+     * @param  the return type
+     */
+    static final class InvokeAsync implements OnSubscribeFunc {
+        final Func0 function;
+        public InvokeAsync(Func0 function) {
+            if (function == null) {
+                throw new NullPointerException("function");
+            }
+            this.function = function;
+        }
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            Subscription s = Subscriptions.empty();
+            try {
+                t1.onNext(function.call());
+            } catch (Throwable t) {
+                t1.onError(t);
+                return s;
+            }
+            t1.onCompleted();
+            return s;
+        }
+    }
+    /**
+     * Invokes a java.util.concurrent.Callable when an observer subscribes.
+     * @param  the return type
+     */
+    static final class InvokeAsyncCallable implements OnSubscribeFunc {
+        final Callable callable;
+        public InvokeAsyncCallable(Callable callable) {
+            if (callable == null) {
+                throw new NullPointerException("function");
+            }
+            this.callable = callable;
+        }
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            Subscription s = Subscriptions.empty();
+            try {
+                t1.onNext(callable.call());
+            } catch (Throwable t) {
+                t1.onError(t);
+                return s;
+            }
+            t1.onCompleted();
+            return s;
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
new file mode 100644
index 0000000000..992023e7f5
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
@@ -0,0 +1,68 @@
+ /**
+  * 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.util.async.operators;
+
+import java.util.concurrent.Future;
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Scheduler;
+import rx.util.functions.Func0;
+
+/**
+ * Start an asynchronous Future immediately and observe its result through
+ * an observable.
+ */
+public final class OperationStartFuture {
+    /** Utility class. */
+    private OperationStartFuture() { throw new IllegalStateException("No instances!"); }
+    /**
+     * Invokes the asynchronous function, surfacing the result through an observable sequence.
+     * 
    
+     * Important note subscribing to the resulting observable blocks until
+     * the future completes.
+     * @param  the result type
+     * @param functionAsync the asynchronous function to run
+     * @return the observable
+     */
+    public static  Observable startFuture(Func0> functionAsync) {
+        Future task;
+        try {
+            task = functionAsync.call();
+        } catch (Throwable t) {
+            return Observable.error(t);
+        }
+        return Observable.from(task);
+    }
+    /**
+     * Invokes the asynchronous function, surfacing the result through an observable sequence
+     * running on the given scheduler.
+     * @param  the result type
+     * @param functionAsync the asynchronous function to run
+     * @param scheduler the scheduler where the completion of the Future is awaited
+     * @return the observable
+     */
+    public static  Observable startFuture(Func0> functionAsync,
+            Scheduler scheduler) {
+        Future task;
+        try {
+            task = functionAsync.call();
+        } catch (Throwable t) {
+            return Observable.error(t);
+        }
+        return Observable.from(task, scheduler);
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
new file mode 100644
index 0000000000..f07d9b5e04
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
@@ -0,0 +1,105 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.fail;
+import org.junit.Test;
+import org.mockito.InOrder;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import rx.Observable;
+import rx.Observer;
+import rx.schedulers.Schedulers;
+import rx.util.async.Async;
+import rx.util.functions.Func0;
+
+public class OperationDeferFutureTest {
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testSimple() throws InterruptedException {
+        final ExecutorService exec = Executors.newCachedThreadPool();
+        try {
+            final CountDownLatch ready = new CountDownLatch(1);
+
+            Func0>> func = new Func0>>() {
+                @Override
+                public Future> call() {
+                    return exec.submit(new Callable>() {
+                        @Override
+                        public Observable call() throws Exception {
+                            if (!ready.await(1000, TimeUnit.MILLISECONDS)) {
+                                throw new IllegalStateException("Not started in time");
+                            }
+                            return Observable.from(1);
+                        }
+                    });
+                }
+            };
+            
+            Observable result = Async.deferFuture(func, Schedulers.threadPoolForComputation());
+
+            final Observer observer = mock(Observer.class);
+
+            final CountDownLatch done = new CountDownLatch(1);
+
+            result.subscribe(new OperationStartFutureTest.MockHelper(observer, done));
+
+            ready.countDown();
+
+            if (!done.await(1000, TimeUnit.MILLISECONDS)) {
+                fail("Not completed in time!");
+            }
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer).onNext(1);
+            inOrder.verify(observer).onCompleted();
+            verify(observer, never()).onError(any(Throwable.class));
+        } finally {
+            exec.shutdown();
+        }
+    }
+    
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testSimpleFactoryThrows() {
+        Func0>> func = new Func0>>() {
+
+            @Override
+            public Future> call() {
+                throw new OperationStartFutureTest.CustomException();
+            }
+        };
+        
+        Observable result = Async.deferFuture(func);
+        
+        final Observer observer = mock(Observer.class);
+        result.subscribe(observer);
+        
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer).onError(any(OperationStartFutureTest.CustomException.class));
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
new file mode 100644
index 0000000000..e5915050ee
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
@@ -0,0 +1,170 @@
+ /**
+  * 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.util.async.operators;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import org.junit.Test;
+import rx.Observable;
+import rx.schedulers.Schedulers;
+import rx.util.async.Async;
+import rx.util.functions.Action1;
+
+public class OperationForEachFutureTest {
+    @Test
+    public void testSimple() {
+        final ExecutorService exec = Executors.newCachedThreadPool();
+        
+        try {
+            Observable source = Observable.from(1, 2, 3)
+                    .subscribeOn(Schedulers.threadPoolForComputation());
+            
+            final AtomicInteger sum = new AtomicInteger();
+            Action1 add = new Action1() {
+                @Override
+                public void call(Integer t1) {
+                    sum.addAndGet(t1);
+                }
+            };
+            
+            FutureTask task = Async.forEachFuture(source, add);
+            
+            exec.execute(task);
+            
+            try {
+                Void value = task.get(1000, TimeUnit.MILLISECONDS);
+                
+                assertEquals(null, value);
+                
+                assertEquals(6, sum.get());
+            } catch (TimeoutException ex) {
+                fail("Timed out: " + ex);
+            } catch (ExecutionException ex) {
+                fail("Exception: " + ex);
+            } catch (InterruptedException ex) {
+                fail("Exception: " + ex);
+            }
+        } finally {
+            exec.shutdown();
+        }
+    }
+    private static final class CustomException extends RuntimeException { }
+    @Test
+    public void testSimpleThrowing() {
+        
+        final ExecutorService exec = Executors.newCachedThreadPool();
+        
+        try {
+            Observable source = Observable.error(new CustomException())
+                    .subscribeOn(Schedulers.threadPoolForComputation());
+            
+            final AtomicInteger sum = new AtomicInteger();
+            Action1 add = new Action1() {
+                @Override
+                public void call(Integer t1) {
+                    sum.addAndGet(t1);
+                }
+            };
+            
+            FutureTask task = Async.forEachFuture(source, add);
+            
+            exec.execute(task);
+            
+            try {
+                task.get(1000, TimeUnit.MILLISECONDS);
+            } catch (TimeoutException ex) {
+                fail("Timed out: " + ex);
+            } catch (ExecutionException ex) {
+                if (!(ex.getCause() instanceof CustomException)) {
+                    fail("Got different exception: " + ex.getCause());
+                }
+            } catch (InterruptedException ex) {
+                fail("Exception: " + ex);
+            }
+            
+            assertEquals(0, sum.get());
+        } finally {
+            exec.shutdown();
+        }
+    }
+    
+    @Test
+    public void testSimpleScheduled() {
+        Observable source = Observable.from(1, 2, 3)
+                .subscribeOn(Schedulers.threadPoolForComputation());
+        
+        final AtomicInteger sum = new AtomicInteger();
+        Action1 add = new Action1() {
+            @Override
+            public void call(Integer t1) {
+                sum.addAndGet(t1);
+            }
+        };
+        
+        FutureTask task = Async.forEachFuture(source, add, Schedulers.newThread());
+        
+        try {
+            Void value = task.get(1000, TimeUnit.MILLISECONDS);
+            
+            assertEquals(null, value);
+            
+            assertEquals(6, sum.get());
+        } catch (TimeoutException ex) {
+            fail("Timed out: " + ex);
+        } catch (ExecutionException ex) {
+            fail("Exception: " + ex);
+        } catch (InterruptedException ex) {
+            fail("Exception: " + ex);
+        }
+    }
+    @Test
+    public void testSimpleScheduledThrowing() {
+        
+        Observable source = Observable.error(new CustomException())
+                .subscribeOn(Schedulers.threadPoolForComputation());
+        
+        final AtomicInteger sum = new AtomicInteger();
+        Action1 add = new Action1() {
+            @Override
+            public void call(Integer t1) {
+                sum.addAndGet(t1);
+            }
+        };
+        
+        FutureTask task = Async.forEachFuture(source, add, Schedulers.newThread());
+        
+        try {
+            task.get(1000, TimeUnit.MILLISECONDS);
+        } catch (TimeoutException ex) {
+            fail("Timed out: " + ex);
+        } catch (ExecutionException ex) {
+            if (!(ex.getCause() instanceof CustomException)) {
+                fail("Got different exception: " + ex.getCause());
+            }
+        } catch (InterruptedException ex) {
+            fail("Exception: " + ex);
+        }
+        
+        assertEquals(0, sum.get());
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
new file mode 100644
index 0000000000..ebd741bc4f
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
@@ -0,0 +1,241 @@
+/**
+ * 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.util.async.operators;
+
+import java.io.IOException;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import junit.framework.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.schedulers.TestScheduler;
+import rx.util.async.Async;
+import rx.util.functions.Action0;
+import rx.util.functions.Func0;
+
+public class OperationFromFunctionalsTest {
+    TestScheduler scheduler;
+    @Before
+    public void before() {
+        scheduler = new TestScheduler();
+    }
+    private void testRunShouldThrow(Observable source, Class exception) {
+        for (int i = 0; i < 3; i++) {
+            
+            Observer observer = mock(Observer.class);
+            source.subscribe(observer);
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer, never()).onError(any(Throwable.class));
+
+            scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
+
+            inOrder.verify(observer, times(1)).onError(any(exception));
+            verify(observer, never()).onNext(any());
+            verify(observer, never()).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+        }
+    }
+    @Test
+    public void testFromAction() {
+        final AtomicInteger value = new AtomicInteger();
+        
+        Action0 action = new Action0() {
+            @Override
+            public void call() {
+                value.set(2);
+            }
+        };
+        
+        Observable source = Async.fromAction(action, 1, scheduler);
+        
+        for (int i = 0; i < 3; i++) {
+            
+            value.set(0);
+            
+            Observer observer = mock(Observer.class);
+            source.subscribe(observer);
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer, never()).onNext(any());
+            inOrder.verify(observer, never()).onCompleted();
+
+            scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
+
+            inOrder.verify(observer, times(1)).onNext(1);
+            inOrder.verify(observer, times(1)).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+            verify(observer, never()).onError(any(Throwable.class));
+
+            Assert.assertEquals(2, value.get());
+        }
+    }
+    @Test
+    public void testFromActionThrows() {
+        Action0 action = new Action0() {
+            @Override
+            public void call() {
+                throw new RuntimeException("Forced failure!");
+            }
+        };
+        
+        Observable source = Async.fromAction(action, 1, scheduler);
+        
+        testRunShouldThrow(source, RuntimeException.class);
+    }
+    @Test
+    public void testFromFunc0() {
+        Func0 func = new Func0() {
+            @Override
+            public Integer call() {
+                return 1;
+            }
+        };
+        
+        Observable source = Async.fromFunc0(func, scheduler);
+        
+        for (int i = 0; i < 3; i++) {
+            
+            Observer observer = mock(Observer.class);
+            source.subscribe(observer);
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer, never()).onNext(any());
+            inOrder.verify(observer, never()).onCompleted();
+
+            scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
+
+            inOrder.verify(observer, times(1)).onNext(1);
+            inOrder.verify(observer, times(1)).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+            verify(observer, never()).onError(any(Throwable.class));
+        }
+    }
+    
+    @Test
+    public void testFromFunc0Throws() {
+        Func0 func = new Func0() {
+            @Override
+            public Integer call() {
+                throw new RuntimeException("Forced failure!");
+            }
+        };
+        
+        Observable source = Async.fromFunc0(func, scheduler);
+        
+        testRunShouldThrow(source, RuntimeException.class);
+    }
+    @Test
+    public void testFromRunnable() {
+        final AtomicInteger value = new AtomicInteger();
+        
+        Runnable action = new Runnable() {
+            @Override
+            public void run() {
+                value.set(2);
+            }
+        };
+        
+        Observable source = Async.fromRunnable(action, 1, scheduler);
+        
+        for (int i = 0; i < 3; i++) {
+            
+            value.set(0);
+            
+            Observer observer = mock(Observer.class);
+            source.subscribe(observer);
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer, never()).onNext(any());
+            inOrder.verify(observer, never()).onCompleted();
+
+            scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
+
+            inOrder.verify(observer, times(1)).onNext(1);
+            inOrder.verify(observer, times(1)).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+            verify(observer, never()).onError(any(Throwable.class));
+
+            Assert.assertEquals(2, value.get());
+        }
+    }
+    @Test
+    public void testFromRunnableThrows() {
+        Runnable action = new Runnable() {
+            @Override
+            public void run() {
+                throw new RuntimeException("Forced failure!");
+            }
+        };
+        
+        Observable source = Async.fromRunnable(action, 1, scheduler);
+        
+        testRunShouldThrow(source, RuntimeException.class);
+    }
+    @Test
+    public void testFromCallable() {
+        Callable callable = new Callable() {
+            @Override
+            public Integer call() throws Exception {
+                return 1;
+            }
+        };
+        
+        Observable source = Async.fromCallable(callable, scheduler);
+        
+        for (int i = 0; i < 3; i++) {
+            
+            Observer observer = mock(Observer.class);
+            source.subscribe(observer);
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer, never()).onNext(any());
+            inOrder.verify(observer, never()).onCompleted();
+
+            scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
+
+            inOrder.verify(observer, times(1)).onNext(1);
+            inOrder.verify(observer, times(1)).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+            verify(observer, never()).onError(any(Throwable.class));
+        }
+    }
+    
+    @Test
+    public void testFromCallableThrows() {
+        Callable callable = new Callable() {
+            @Override
+            public Integer call() throws Exception {
+                throw new IOException("Forced failure!");
+            }
+        };
+        
+        Observable source = Async.fromCallable(callable, scheduler);
+        
+        testRunShouldThrow(source, IOException.class);
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
new file mode 100644
index 0000000000..733fdb39b3
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
@@ -0,0 +1,147 @@
+/**
+ * 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.util.async.operators;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.fail;
+import org.junit.Test;
+import org.mockito.InOrder;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.schedulers.Schedulers;
+import rx.util.async.Async;
+import rx.util.functions.Func0;
+
+public class OperationStartFutureTest {
+    /** Custom exception to distinguish from any other RuntimeException. */
+    static class CustomException extends RuntimeException {}
+    /** 
+     * Forwards the events to the underlying observer and counts down the latch
+     * on terminal conditions.
+     * @param  
+     */
+    static class MockHelper implements Observer {
+        final Observer observer;
+        final CountDownLatch latch;
+
+        public MockHelper(Observer observer, CountDownLatch latch) {
+            this.observer = observer;
+            this.latch = latch;
+        }
+
+        @Override
+        public void onNext(T args) {
+            try {
+                observer.onNext(args);
+            } catch (Throwable t) {
+                onError(t);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            try {
+                observer.onError(e);
+            } finally {
+                latch.countDown();
+            }
+        }
+
+
+        @Override
+        public void onCompleted() {
+            try {
+                observer.onCompleted();
+            } finally {
+                latch.countDown();
+            }
+        }
+        
+    }
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testSimple() throws InterruptedException {
+        final ExecutorService exec = Executors.newCachedThreadPool();
+        try {
+            final CountDownLatch ready = new CountDownLatch(1);
+
+            Func0> func = new Func0>() {
+
+                @Override
+                public Future call() {
+                    return exec.submit(new Callable() {
+                        @Override
+                        public Integer call() throws Exception {
+                            if (!ready.await(1000, TimeUnit.MILLISECONDS)) {
+                                throw new IllegalStateException("Not started in time");
+                            }
+                            return 1;
+                        }
+                    });
+                }
+            };
+
+            Observable result = Async.startFuture(func, Schedulers.threadPoolForComputation());
+
+            final Observer observer = mock(Observer.class);
+
+            final CountDownLatch done = new CountDownLatch(1);
+
+            result.subscribe(new MockHelper(observer, done));
+
+            ready.countDown();
+
+            if (!done.await(1000, TimeUnit.MILLISECONDS)) {
+                fail("Not completed in time!");
+            }
+
+            InOrder inOrder = inOrder(observer);
+
+            inOrder.verify(observer).onNext(1);
+            inOrder.verify(observer).onCompleted();
+            verify(observer, never()).onError(any(Throwable.class));
+        } finally {        
+            exec.shutdown();
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testSimpleFactoryThrows() {
+        Func0> func = new Func0>() {
+
+            @Override
+            public Future call() {
+                throw new CustomException();
+            }
+        };
+        
+        Observable result = Async.startFuture(func);
+        
+        final Observer observer = mock(Observer.class);
+        result.subscribe(observer);
+        
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer).onError(any(CustomException.class));
+    }
+}

From 0da74ba59f780a5986859e3e7204169bc1da1e6f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 10:17:16 -0800
Subject: [PATCH 158/441] Manual Merge of Pull #616

Manual merge of https://github.com/Netflix/RxJava/pull/616

- remove use of SingleAssignmentSubscription
- suppress warnings
---
 .../rx/operators/OperationCombineLatest.java  | 47 +++++++++++++------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
index fcf1caf051..272ac6af7f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
@@ -27,7 +27,6 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SingleAssignmentSubscription;
 import rx.util.functions.Func2;
 import rx.util.functions.Func3;
 import rx.util.functions.Func4;
@@ -61,6 +60,7 @@ public class OperationCombineLatest {
      *            The aggregation function used to combine the source observable values.
      * @return A function from an observer to a subscription. This can be used to create an observable from.
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction) {
         return new CombineLatest(Arrays.asList(w0, w1), Functions.fromFunc(combineLatestFunction));
     }
@@ -68,30 +68,34 @@ public static  OnSubscribeFunc combineLatest(Observable OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2,
             Func3 combineLatestFunction) {
-        return new CombineLatest(Arrays.asList(w0, w1, w2), Functions.fromFunc(combineLatestFunction));    
+        return new CombineLatest(Arrays.asList(w0, w1, w2), Functions.fromFunc(combineLatestFunction));
     }
 
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3,
             Func4 combineLatestFunction) {
-                return new CombineLatest(Arrays.asList(w0, w1, w2, w3), Functions.fromFunc(combineLatestFunction));
+        return new CombineLatest(Arrays.asList(w0, w1, w2, w3), Functions.fromFunc(combineLatestFunction));
     }
 
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4,
             Func5 combineLatestFunction) {
-                return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4), Functions.fromFunc(combineLatestFunction));
+        return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4), Functions.fromFunc(combineLatestFunction));
     }
 
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5,
             Func6 combineLatestFunction) {
         return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5), Functions.fromFunc(combineLatestFunction));
@@ -100,6 +104,7 @@ public static  OnSubscribeFunc combineLatest(Obser
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6,
             Func7 combineLatestFunction) {
         return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5, w6), Functions.fromFunc(combineLatestFunction));
@@ -108,6 +113,7 @@ public static  OnSubscribeFunc combineLatest(O
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6, Observable w7,
             Func8 combineLatestFunction) {
         return new CombineLatest(Arrays.asList(w0, w1, w2, w3, w4, w5, w6, w7), Functions.fromFunc(combineLatestFunction));
@@ -116,6 +122,7 @@ public static  OnSubscribeFunc combineLate
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
+    @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc combineLatest(Observable w0, Observable w1, Observable w2, Observable w3, Observable w4, Observable w5, Observable w6, Observable w7,
             Observable w8,
             Func9 combineLatestFunction) {
@@ -125,6 +132,7 @@ public static  OnSubscribeFunc combine
     static final class CombineLatest implements OnSubscribeFunc {
         final List> sources;
         final FuncN combiner;
+
         public CombineLatest(Iterable> sources, FuncN combiner) {
             this.sources = new ArrayList>();
             this.combiner = combiner;
@@ -136,27 +144,28 @@ public CombineLatest(Iterable> sources, FuncN<
         @Override
         public Subscription onSubscribe(Observer t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             Collector collector = new Collector(t1, csub, sources.size());
-            
+
             int index = 0;
             List observers = new ArrayList(sources.size() + 1);
             for (Observable source : sources) {
-                SingleAssignmentSubscription sas = new SingleAssignmentSubscription();
+                SafeObservableSubscription sas = new SafeObservableSubscription();
                 csub.add(sas);
                 observers.add(new SourceObserver(collector, sas, index, source));
                 index++;
             }
-            
+
             for (SourceObserver so : observers) {
                 // if we run to completion, don't bother any further
                 if (!csub.isUnsubscribed()) {
                     so.connect();
                 }
             }
-            
+
             return csub;
         }
+
         /**
          * The collector that combines the latest values from many sources.
          */
@@ -173,6 +182,7 @@ final class Collector {
             int hasCount;
             /** Number of completed source observers. */
             int completedCount;
+
             public Collector(Observer observer, Subscription cancel, int count) {
                 this.observer = observer;
                 this.cancel = cancel;
@@ -181,6 +191,7 @@ public Collector(Observer observer, Subscription cancel, int count) {
                 this.completed = new BitSet(count);
                 this.lock = new ReentrantLock();
             }
+
             public void next(int index, T value) {
                 Throwable err = null;
                 lock.lock();
@@ -210,6 +221,7 @@ public void next(int index, T value) {
                     cancel.unsubscribe();
                 }
             }
+
             public void error(int index, Throwable e) {
                 boolean unsub = false;
                 lock.lock();
@@ -226,13 +238,16 @@ public void error(int index, Throwable e) {
                     cancel.unsubscribe();
                 }
             }
+
             boolean isTerminated() {
                 return completedCount == values.length + 1;
             }
+
             void terminate() {
                 completedCount = values.length + 1;
                 Arrays.fill(values, null);
             }
+
             public void completed(int index) {
                 boolean unsub = false;
                 lock.lock();
@@ -256,22 +271,25 @@ public void completed(int index) {
                 }
             }
         }
+
         /**
          * Observes a specific source and communicates with the collector.
          */
-        final class SourceObserver implements Observer  {
-            final SingleAssignmentSubscription self;
+        final class SourceObserver implements Observer {
+            final SafeObservableSubscription self;
             final Collector collector;
             final int index;
             Observable source;
-            public SourceObserver(Collector collector, 
-                    SingleAssignmentSubscription self, int index,
+
+            public SourceObserver(Collector collector,
+                    SafeObservableSubscription self, int index,
                     Observable source) {
                 this.self = self;
                 this.collector = collector;
                 this.index = index;
                 this.source = source;
             }
+
             @Override
             public void onNext(T args) {
                 collector.next(index, args);
@@ -287,9 +305,10 @@ public void onCompleted() {
                 collector.completed(index);
                 self.unsubscribe();
             }
+
             /** Connect to the source. */
             void connect() {
-                self.set(source.subscribe(this));
+                self.wrap(source.subscribe(this));
                 source = null;
             }
         }

From 40f222fae9d14735a59e104bf3aaf66482e0dfe6 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Mon, 30 Dec 2013 14:23:02 -0800
Subject: [PATCH 159/441] Lotsa javadoc improvements * diagrams for
 previously-undiagram'd methods * links to wiki docs where available *
 standardizing format & nomenclature

---
 .../src/main/java/rx/util/async/Async.java    | 895 +++++++++---------
 1 file changed, 452 insertions(+), 443 deletions(-)

diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index dbbafbd50f..ad178ca365 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -69,19 +69,14 @@ private Async() {
      * observer subscribes to the resulting Observable. Multiple subscriptions
      * to this Observable observe the same return value.
      * 
    
-     * 
+     * 
      *
      * @param  the result value type
      * @param func function to run asynchronously
      * @return an Observable that emits the function's result value, or notifies
-     * observers of an exception
-     * @see RxJava
-     * Wiki: start()
-     * @see MSDN:
-     * Observable.Start
+     *         observers of an exception
+     * @see RxJava Wiki: start()
+     * @see MSDN: Observable.Start
      */
     public static  Observable start(Func0 func) {
         return Async.toAsync(func).call();
@@ -95,20 +90,15 @@ public static  Observable start(Func0 func) {
      * observer subscribes to the resulting Observable. Multiple subscriptions
      * to this Observable observe the same return value.
      * 
    
-     * 
+     * 
      *
      * @param  the result value type
      * @param func function to run asynchronously
      * @param scheduler scheduler to run the function on
      * @return an Observable that emits the function's result value, or notifies
-     * observers of an exception
-     * @see RxJava
-     * Wiki: start()
-     * @see MSDN:
-     * Observable.Start
+     *         observers of an exception
+     * @see RxJava Wiki: start()
+     * @see MSDN: Observable.Start
      */
     public static  Observable start(Func0 func, Scheduler scheduler) {
         return Async.toAsync(func, scheduler).call();
@@ -116,16 +106,15 @@ public static  Observable start(Func0 func, Scheduler scheduler) {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(Action0 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -133,17 +122,16 @@ public static Func0> toAsync(Action0 action) {
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the result value type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(Func0 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -151,17 +139,16 @@ public static  Func0> toAsync(Func0 func) {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  first parameter type of the action
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Action1 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -169,18 +156,17 @@ public static  Func1> toAsync(Action1 actio
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  first parameter type of the action
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Func1 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -188,18 +174,17 @@ public static  Func1> toAsync(Func1
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Action2 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -207,19 +192,18 @@ public static  Func2> toAsync(Action2
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Func2 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -227,19 +211,18 @@ public static  Func2> toAsync(Func2
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the third parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Action3 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -247,20 +230,19 @@ public static  Func3> toAsync(Action3
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the third parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Func3 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -268,20 +250,19 @@ public static  Func3> toAsync(Func3
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the third parameter type
      * @param  the fourth parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(Action4 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -289,7 +270,9 @@ public static  Func4> toAsync(A
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -297,13 +280,10 @@ public static  Func4> toAsync(A
      * @param  the fourth parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(Func4 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -311,7 +291,9 @@ public static  Func4> toAsync(F
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -319,13 +301,10 @@ public static  Func4> toAsync(F
      * @param  the fourth parameter type
      * @param  the fifth parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Action5 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -333,7 +312,9 @@ public static  Func5> t
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -342,13 +323,10 @@ public static  Func5> t
      * @param  the fifth parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Func5 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -356,7 +334,9 @@ public static  Func5> t
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -365,13 +345,10 @@ public static  Func5> t
      * @param  the fifth parameter type
      * @param  the sixth parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Action6 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -379,7 +356,9 @@ public static  Func6
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -389,13 +368,10 @@ public static  Func6 the sixth parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Func6 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -403,7 +379,9 @@ public static  Func6
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -413,13 +391,10 @@ public static  Func6 the sixth parameter type
      * @param  the seventh parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Action7 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -427,7 +402,9 @@ public static  Func7
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -438,13 +415,10 @@ public static  Func7 the seventh parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Func7 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -452,7 +426,9 @@ public static  Func7
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -463,13 +439,10 @@ public static  Func7 the seventh parameter type
      * @param  the eighth parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Action8 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -477,7 +450,9 @@ public static  Func8
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -489,13 +464,10 @@ public static  Func8 the eighth parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Func8 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -503,7 +475,9 @@ public static  Func8
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -515,13 +489,10 @@ public static  Func8 the eighth parameter type
      * @param  the ninth parameter type
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Action9 action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -529,7 +500,9 @@ public static  Func9
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -542,13 +515,10 @@ public static  Func9 the ninth parameter type
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Func9 func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -556,13 +526,14 @@ public static  Func9
+     * 
      *
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
      */
     public static FuncN> toAsync(ActionN action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -570,14 +541,15 @@ public static FuncN> toAsync(ActionN action) {
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
      */
     public static  FuncN> toAsync(FuncN func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -585,17 +557,16 @@ public static  FuncN> toAsync(FuncN func) {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(final Action0 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -603,18 +574,17 @@ public static Func0> toAsync(final Action0 action, final Schedu
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(final Func0 func, final Scheduler scheduler) {
         return new Func0>() {
@@ -642,18 +612,17 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Action1 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -661,19 +630,18 @@ public static  Func1> toAsync(final Action1
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Func1 func, final Scheduler scheduler) {
         return new Func1>() {
@@ -701,19 +669,18 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Action2 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -721,20 +688,19 @@ public static  Func2> toAsync(final Action2
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Func2 func, final Scheduler scheduler) {
         return new Func2>() {
@@ -762,20 +728,19 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
      * @param  the third parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Action3 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -783,7 +748,9 @@ public static  Func3> toAsync(final Act
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -791,13 +758,10 @@ public static  Func3> toAsync(final Act
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Func3 func, final Scheduler scheduler) {
         return new Func3>() {
@@ -825,7 +789,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -833,13 +799,10 @@ public void call() {
      * @param  the fourth parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Action4 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -847,7 +810,9 @@ public static  Func4> toAsync(f
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -856,13 +821,10 @@ public static  Func4> toAsync(f
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Func4 func, final Scheduler scheduler) {
         return new Func4>() {
@@ -890,7 +852,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -899,13 +863,10 @@ public void call() {
      * @param  the fifth parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Action5 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -913,7 +874,9 @@ public static  Func5> t
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -923,13 +886,10 @@ public static  Func5> t
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Func5 func, final Scheduler scheduler) {
         return new Func5>() {
@@ -957,7 +917,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -967,13 +929,10 @@ public void call() {
      * @param  the sixth parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Action6 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -981,7 +940,9 @@ public static  Func6
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -992,13 +953,10 @@ public static  Func6 the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Func6 func, final Scheduler scheduler) {
         return new Func6>() {
@@ -1026,7 +984,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1037,13 +997,10 @@ public void call() {
      * @param  the seventh parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Action7 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -1051,7 +1008,9 @@ public static  Func7
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1063,13 +1022,10 @@ public static  Func7 the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Func7 func, final Scheduler scheduler) {
         return new Func7>() {
@@ -1097,7 +1053,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1109,13 +1067,10 @@ public void call() {
      * @param  the eighth parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Action8 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -1123,7 +1078,9 @@ public static  Func8
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1136,13 +1093,10 @@ public static  Func8 the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Func8 func, final Scheduler scheduler) {
         return new Func8>() {
@@ -1170,7 +1124,9 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1183,13 +1139,10 @@ public void call() {
      * @param  the ninth parameter type
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Action9 action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -1197,7 +1150,9 @@ public static  Func9
+     * 
      *
      * @param  the first parameter type
      * @param  the second parameter type
@@ -1211,13 +1166,10 @@ public static  Func9 the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
-     * @see MSDN:
-     * Observable.ToAsync
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
+     * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Func9 func, final Scheduler scheduler) {
         return new Func9>() {
@@ -1245,14 +1197,15 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: toAsync()
      */
     public static FuncN> toAsync(final ActionN action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -1260,15 +1213,16 @@ public static FuncN> toAsync(final ActionN action, final Schedu
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
+     * @see RxJava Wiki: toAsync()
      */
     public static  FuncN> toAsync(final FuncN func, final Scheduler scheduler) {
         return new FuncN>() {
@@ -1296,15 +1250,15 @@ public void call() {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      * 
    
      * Alias for toAsync(ActionN) intended for dynamic languages.
      *
      * @param action the action to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
      */
     public static FuncN> asyncAction(final ActionN action) {
         return toAsync(action);
@@ -1312,16 +1266,16 @@ public static FuncN> asyncAction(final ActionN action) {
     
     /**
      * Convert a synchronous action call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      * 
    
      * Alias for toAsync(ActionN, Scheduler) intended for dynamic languages.
      *
      * @param action the action to convert
      * @param scheduler the scheduler used to execute the {@code action}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code action} and emits {@code null}.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code action} and emits {@code null}
      */
     public static FuncN> asyncAction(final ActionN action, final Scheduler scheduler) {
         return toAsync(action, scheduler);
@@ -1329,16 +1283,16 @@ public static FuncN> asyncAction(final ActionN action, final Sc
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      * 
    
      * Alias for toAsync(FuncN) intended for dynamic languages.
      *
      * @param  the result type
      * @param func the function to convert
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
      */
     public static  FuncN> asyncFunc(final FuncN func) {
         return toAsync(func);
@@ -1346,17 +1300,17 @@ public static  FuncN> asyncFunc(final FuncN func)
     
     /**
      * Convert a synchronous function call into an asynchronous function call
-     * through an Observable sequence.
+     * through an Observable.
+     * 
    
+     * 
      * 
    
      * Alias for toAsync(FuncN, Scheduler) intended for dynamic languages.
      *
      * @param  the result type
      * @param func the function to convert
      * @param scheduler the scheduler used to call the {@code func}
-     *
-     * @return a function which returns an observable sequence which executes
-     * the {@code func} and emits its returned value.
-     *
+     * @return a function that returns an Observable that executes the
+     *         {@code func} and emits its returned value
      */
     public static  FuncN> asyncFunc(final FuncN func, final Scheduler scheduler) {
         return toAsync(func, scheduler);
@@ -1364,14 +1318,16 @@ public static  FuncN> asyncFunc(final FuncN func,
     
     /**
      * Invokes the asynchronous function immediately, surfacing the result
-     * through an observable sequence.
+     * through an Observable.
      * 
    
-     * Important note subscribing to the resulting observable blocks
+     * Important note subscribing to the resulting Observable blocks
      * until the future completes.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param functionAsync the asynchronous function to run
-     * @return an observable which surfaces the result of the future.
+     * @return an Observable that surfaces the result of the future
      * @see #startFuture(rx.util.functions.Func0, rx.Scheduler)
      */
     public static  Observable startFuture(Func0> functionAsync) {
@@ -1380,13 +1336,15 @@ public static  Observable startFuture(Func0>
     
     /**
      * Invokes the asynchronous function immediately, surfacing the result
-     * through an observable sequence and waits on the specified scheduler.
+     * through an Observable and waits on the specified scheduler.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param functionAsync the asynchronous function to run
      * @param scheduler the scheduler where the completion of the Future is
-     * awaited
-     * @return an observable which surfaces the result of the future.
+     *                  awaited
+     * @return an Observable that surfaces the result of the future
      */
     public static  Observable startFuture(Func0> functionAsync,
         Scheduler scheduler) {
@@ -1394,17 +1352,19 @@ public static  Observable startFuture(Func0>
     }
     
     /**
-     * Returns an observable sequence that starts the specified asynchronous
-     * factory function whenever a new observer subscribes.
+     * Returns an Observable that starts the specified asynchronous factory
+     * function whenever a new observer subscribes.
      * 
    
-     * Important note subscribing to the resulting observable blocks
+     * Important note subscribing to the resulting Observable blocks
      * until the future completes.
+     * 
    
+     * 
      *
      * @param  the result type
      * @param observableFactoryAsync the asynchronous function to start for each
-     * observer
-     * @return the observable sequence containing values produced by the
-     * asynchronous observer produced by the factory
+     *                               observer
+     * @return the Observable emitting items produced by the asynchronous
+     *         observer produced by the factory
      * @see #deferFuture(rx.util.functions.Func0, rx.Scheduler)
      */
     public static  Observable deferFuture(Func0>> observableFactoryAsync) {
@@ -1412,16 +1372,18 @@ public static  Observable deferFuture(Func0
+     * 
      *
      * @param  the result type
      * @param observableFactoryAsync the asynchronous function to start for each
-     * observer
+     *                               observer
      * @param scheduler the scheduler where the completion of the Future is
-     * awaited
-     * @return the observable sequence containing values produced by the
-     * asynchronous observer produced by the factory
+     *                  awaited
+     * @return the Observable emitting items produced by the asynchronous
+     *         observer produced by the factory
      */
     public static  Observable deferFuture(
         Func0>> observableFactoryAsync,
@@ -1435,8 +1397,11 @@ public static  Observable deferFuture(
      * 
    
      * Important note: The returned task blocks indefinitely unless
      * the run() method is called or the task is scheduled on an Executor.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.util.functions.Action1, rx.Scheduler)
@@ -1449,13 +1414,16 @@ public static  FutureTask forEachFuture(
     
     
     /**
-     * Subscribes to the given source and calls the callback for each emitted item,
-     * and surfaces the completion or error through a Future.
+     * Subscribes to the given source and calls the callback for each emitted
+     * item, and surfaces the completion or error through a Future.
      * 
    
      * Important note: The returned task blocks indefinitely unless
      * the run() method is called or the task is scheduled on an Executor.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @param onError the action to call when an exception is emitted
      * @return the Future representing the entire for-each operation
@@ -1470,13 +1438,16 @@ public static  FutureTask forEachFuture(
     
     
     /**
-     * Subscribes to the given source and calls the callback for each emitted item,
-     * and surfaces the completion or error through a Future.
+     * Subscribes to the given source and calls the callback for each emitted
+     * item, and surfaces the completion or error through a Future.
      * 
    
      * Important note: The returned task blocks indefinitely unless
      * the run() method is called or the task is scheduled on an Executor.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @param onError the action to call when an exception is emitted
      * @param onCompleted the action to call when the source completes
@@ -1493,12 +1464,17 @@ public static  FutureTask forEachFuture(
     
     
     /**
-     * Subscribes to the given source and calls the callback for each emitted item,
-     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * Subscribes to the given source and calls the callback for each emitted
+     * item, and surfaces the completion or error through a Future, scheduled on
+     * the given scheduler.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
-     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @param scheduler the scheduler where the task will await the termination
+     *                  of the for-each
      * @return the Future representing the entire for-each operation
      */
     public static  FutureTask forEachFuture(
@@ -1512,13 +1488,18 @@ public static  FutureTask forEachFuture(
     
     
     /**
-     * Subscribes to the given source and calls the callback for each emitted item,
-     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * Subscribes to the given source and calls the callback for each emitted
+     * item, and surfaces the completion or error through a Future, scheduled on
+     * the given scheduler.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @param onError the action to call when an exception is emitted
-     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @param scheduler the scheduler where the task will await the termination
+     *                  of the for-each
      * @return the Future representing the entire for-each operation
      */
     public static  FutureTask forEachFuture(
@@ -1533,14 +1514,19 @@ public static  FutureTask forEachFuture(
     
     
     /**
-     * Subscribes to the given source and calls the callback for each emitted item,
-     * and surfaces the completion or error through a Future, scheduled on the given scheduler.
+     * Subscribes to the given source and calls the callback for each emitted
+     * item, and surfaces the completion or error through a Future, scheduled on
+     * the given scheduler.
+     * 
    
+     * 
+     *
      * @param  the source value type
-     * @param source the source Observable sequence
+     * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @param onError the action to call when an exception is emitted
      * @param onCompleted the action to call when the source completes
-     * @param scheduler the scheduler where the task will await the termination of the for-each
+     * @param scheduler the scheduler where the task will await the termination
+     *                  of the for-each
      * @return the Future representing the entire for-each operation
      */
     public static  FutureTask forEachFuture(
@@ -1555,46 +1541,54 @@ public static  FutureTask forEachFuture(
     }
     
     /**
-     * Return an Observable which calls the given action and emits the given
+     * Return an Observable that calls the given action and emits the given
      * result when an Observer subscribes.
      * 
    
+     * 
+     * 
    
      * The action is run on the default thread pool for computation.
+     *
      * @param  the return type
      * @param action the action to invoke on each subscription
      * @param result the result to emit to observers
-     * @return an Observable which calls the given action and emits the given
-     * result when an Observer subscribes
+     * @return an Observable that calls the given action and emits the given
+     *         result when an Observer subscribes
      */
     public static  Observable fromAction(Action0 action, R result) {
         return fromAction(action, result, Schedulers.threadPoolForComputation());
     }
     
     /**
-     * Return an Observable which calls the given function and emits its
+     * Return an Observable that calls the given function and emits its
      * result when an Observer subscribes.
      * 
    
+     * 
+     * 
    
      * The function is called on the default thread pool for computation.
      * 
      * @param  the return type
      * @param function the function to call on each subscription
-     * @return an Observable which calls the given function and emits its
-     * result when an Observer subscribes
+     * @return an Observable that calls the given function and emits its
+     *         result when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      */
     public static  Observable fromFunc0(Func0 function) {
         return fromFunc0(function, Schedulers.threadPoolForComputation());
     }
+
     /**
-     * Return an Observable which calls the given Callable and emits its
+     * Return an Observable that calls the given Callable and emits its
      * result or Exception when an Observer subscribes.
      * 
    
+     * 
+     * 
    
      * The Callable is called on the default thread pool for computation.
      * 
      * @param  the return type
      * @param callable the callable to call on each subscription
-     * @return an Observable which calls the given Callable and emits its
-     * result or Exception when an Observer subscribes
+     * @return an Observable that calls the given Callable and emits its
+     *         result or Exception when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromFunc0(rx.util.functions.Func0) 
      */
@@ -1603,60 +1597,72 @@ public static  Observable fromCallable(Callable callable) {
     }
     
     /**
-     * Return an Observable which calls the given Runnable and emits the given
+     * Return an Observable that calls the given Runnable and emits the given
      * result when an Observer subscribes.
      * 
    
+     * 
+     * 
    
      * The Runnable is called on the default thread pool for computation.
      * 
      * @param  the return type
      * @param run the runnable to invoke on each subscription
      * @param result the result to emit to observers
-     * @return an Observable which calls the given Runnable and emits the given
-     * result when an Observer subscribes
+     * @return an Observable that calls the given Runnable and emits the given
+     *         result when an Observer subscribes
      */
     public static  Observable fromRunnable(final Runnable run, final R result) {
         return fromRunnable(run, result, Schedulers.threadPoolForComputation());
     }
     
     /**
-     * Return an Observable which calls the given action and emits the given
+     * Return an Observable that calls the given action and emits the given
      * result when an Observer subscribes.
+     * 
    
+     * 
      * 
      * @param  the return type
      * @param action the action to invoke on each subscription
-     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @param scheduler the scheduler where the function is called and the
+     *                  result is emitted
      * @param result the result to emit to observers
-     * @return an Observable which calls the given action and emits the given
-     * result when an Observer subscribes
+     * @return an Observable that calls the given action and emits the given
+     *         result when an Observer subscribes
      */
     public static  Observable fromAction(Action0 action, R result, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
     }
     
     /**
-     * Return an Observable which calls the given function and emits its
+     * Return an Observable that calls the given function and emits its
      * result when an Observer subscribes.
+     * 
    
+     * 
      * 
      * @param  the return type
      * @param function the function to call on each subscription
-     * @param scheduler the scheduler where the function is called and the result is emitted
-     * @return an Observable which calls the given function and emits its
-     * result when an Observer subscribes
+     * @param scheduler the scheduler where the function is called and the
+     *                  result is emitted
+     * @return an Observable that calls the given function and emits its
+     *         result when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      */
     public static  Observable fromFunc0(Func0 function, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromFunc0(function)).subscribeOn(scheduler);
     }
+
     /**
-     * Return an Observable which calls the given Callable and emits its
+     * Return an Observable that calls the given Callable and emits its
      * result or Exception when an Observer subscribes.
+     * 
    
+     * 
      * 
      * @param  the return type
      * @param callable the callable to call on each subscription
-     * @param scheduler the scheduler where the function is called and the result is emitted
-     * @return an Observable which calls the given Callable and emits its
-     * result or Exception when an Observer subscribes
+     * @param scheduler the scheduler where the function is called and the
+     *                  result is emitted
+     * @return an Observable that calls the given Callable and emits its
+     *         result or Exception when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromFunc0(rx.util.functions.Func0) 
      */
@@ -1665,15 +1671,18 @@ public static  Observable fromCallable(Callable callable, Sch
     }
     
     /**
-     * Return an Observable which calls the given Runnable and emits the given
+     * Return an Observable that calls the given Runnable and emits the given
      * result when an Observer subscribes.
+     * 
    
+     * 
      * 
      * @param  the return type
      * @param run the runnable to invoke on each subscription
-     * @param scheduler the scheduler where the function is called and the result is emitted
+     * @param scheduler the scheduler where the function is called and the
+     *                  result is emitted
      * @param result the result to emit to observers
-     * @return an Observable which calls the given Runnable and emits the given
-     * result when an Observer subscribes
+     * @return an Observable that calls the given Runnable and emits the given
+     *         result when an Observer subscribes
      */
     public static  Observable fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);

From ea5b7e837cd7cba2bc155c9f2af9513b36fb6734 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Mon, 30 Dec 2013 16:49:42 -0800
Subject: [PATCH 160/441] Created new wiki page for the operators in the Async
 class ...adjusted javadoc links accordingly ...added new sections for
 previously un-wiki-documented operators in Async ...added links to those in
 javadocs

---
 .../src/main/java/rx/util/async/Async.java    | 114 +++++++++++-------
 1 file changed, 68 insertions(+), 46 deletions(-)

diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index ad178ca365..e92cc59aaf 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -75,7 +75,7 @@ private Async() {
      * @param func function to run asynchronously
      * @return an Observable that emits the function's result value, or notifies
      *         observers of an exception
-     * @see RxJava Wiki: start()
+     * @see RxJava Wiki: start()
      * @see MSDN: Observable.Start
      */
     public static  Observable start(Func0 func) {
@@ -97,7 +97,7 @@ public static  Observable start(Func0 func) {
      * @param scheduler scheduler to run the function on
      * @return an Observable that emits the function's result value, or notifies
      *         observers of an exception
-     * @see RxJava Wiki: start()
+     * @see RxJava Wiki: start()
      * @see MSDN: Observable.Start
      */
     public static  Observable start(Func0 func, Scheduler scheduler) {
@@ -113,7 +113,7 @@ public static  Observable start(Func0 func, Scheduler scheduler) {
      * @param action the action to convert
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(Action0 action) {
@@ -130,7 +130,7 @@ public static Func0> toAsync(Action0 action) {
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(Func0 func) {
@@ -147,7 +147,7 @@ public static  Func0> toAsync(Func0 func) {
      * @param action the action to convert
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Action1 action) {
@@ -165,7 +165,7 @@ public static  Func1> toAsync(Action1 actio
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(Func1 func) {
@@ -183,7 +183,7 @@ public static  Func1> toAsync(Func1RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Action2 action) {
@@ -202,7 +202,7 @@ public static  Func2> toAsync(Action2RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(Func2 func) {
@@ -221,7 +221,7 @@ public static  Func2> toAsync(Func2RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Action3 action) {
@@ -241,7 +241,7 @@ public static  Func3> toAsync(Action3RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(Func3 func) {
@@ -261,7 +261,7 @@ public static  Func3> toAsync(Func3RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(Action4 action) {
@@ -282,7 +282,7 @@ public static  Func4> toAsync(A
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(Func4 func) {
@@ -303,7 +303,7 @@ public static  Func4> toAsync(F
      * @param action the action to convert
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Action5 action) {
@@ -325,7 +325,7 @@ public static  Func5> t
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(Func5 func) {
@@ -347,7 +347,7 @@ public static  Func5> t
      * @param action the action to convert
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Action6 action) {
@@ -370,7 +370,7 @@ public static  Func6RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(Func6 func) {
@@ -393,7 +393,7 @@ public static  Func6RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Action7 action) {
@@ -417,7 +417,7 @@ public static  Func7RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(Func7 func) {
@@ -441,7 +441,7 @@ public static  Func7RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Action8 action) {
@@ -466,7 +466,7 @@ public static  Func8RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(Func8 func) {
@@ -491,7 +491,7 @@ public static  Func8RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Action9 action) {
@@ -517,7 +517,7 @@ public static  Func9RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(Func9 func) {
@@ -533,7 +533,7 @@ public static  Func9RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      */
     public static FuncN> toAsync(ActionN action) {
         return toAsync(action, Schedulers.threadPoolForComputation());
@@ -549,7 +549,7 @@ public static FuncN> toAsync(ActionN action) {
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      */
     public static  FuncN> toAsync(FuncN func) {
         return toAsync(func, Schedulers.threadPoolForComputation());
@@ -565,7 +565,7 @@ public static  FuncN> toAsync(FuncN func) {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static Func0> toAsync(final Action0 action, final Scheduler scheduler) {
@@ -583,7 +583,7 @@ public static Func0> toAsync(final Action0 action, final Schedu
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func0> toAsync(final Func0 func, final Scheduler scheduler) {
@@ -621,7 +621,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Action1 action, final Scheduler scheduler) {
@@ -640,7 +640,7 @@ public static  Func1> toAsync(final Action1
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func1> toAsync(final Func1 func, final Scheduler scheduler) {
@@ -679,7 +679,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Action2 action, final Scheduler scheduler) {
@@ -699,7 +699,7 @@ public static  Func2> toAsync(final Action2RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func2> toAsync(final Func2 func, final Scheduler scheduler) {
@@ -739,7 +739,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Action3 action, final Scheduler scheduler) {
@@ -760,7 +760,7 @@ public static  Func3> toAsync(final Act
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func3> toAsync(final Func3 func, final Scheduler scheduler) {
@@ -801,7 +801,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Action4 action, final Scheduler scheduler) {
@@ -823,7 +823,7 @@ public static  Func4> toAsync(f
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func4> toAsync(final Func4 func, final Scheduler scheduler) {
@@ -865,7 +865,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Action5 action, final Scheduler scheduler) {
@@ -888,7 +888,7 @@ public static  Func5> t
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func5> toAsync(final Func5 func, final Scheduler scheduler) {
@@ -931,7 +931,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Action6 action, final Scheduler scheduler) {
@@ -955,7 +955,7 @@ public static  Func6RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func6> toAsync(final Func6 func, final Scheduler scheduler) {
@@ -999,7 +999,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Action7 action, final Scheduler scheduler) {
@@ -1024,7 +1024,7 @@ public static  Func7RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func7> toAsync(final Func7 func, final Scheduler scheduler) {
@@ -1069,7 +1069,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Action8 action, final Scheduler scheduler) {
@@ -1095,7 +1095,7 @@ public static  Func8RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func8> toAsync(final Func8 func, final Scheduler scheduler) {
@@ -1141,7 +1141,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Action9 action, final Scheduler scheduler) {
@@ -1168,7 +1168,7 @@ public static  Func9RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      * @see MSDN: Observable.ToAsync
      */
     public static  Func9> toAsync(final Func9 func, final Scheduler scheduler) {
@@ -1205,7 +1205,7 @@ public void call() {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      */
     public static FuncN> toAsync(final ActionN action, final Scheduler scheduler) {
         return toAsync(Actions.toFunc(action), scheduler);
@@ -1222,7 +1222,7 @@ public static FuncN> toAsync(final ActionN action, final Schedu
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
-     * @see RxJava Wiki: toAsync()
+     * @see RxJava Wiki: toAsync()
      */
     public static  FuncN> toAsync(final FuncN func, final Scheduler scheduler) {
         return new FuncN>() {
@@ -1259,6 +1259,7 @@ public void call() {
      * @param action the action to convert
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: asyncAction()
      */
     public static FuncN> asyncAction(final ActionN action) {
         return toAsync(action);
@@ -1276,6 +1277,7 @@ public static FuncN> asyncAction(final ActionN action) {
      * @param scheduler the scheduler used to execute the {@code action}
      * @return a function that returns an Observable that executes the
      *         {@code action} and emits {@code null}
+     * @see RxJava Wiki: asyncAction()
      */
     public static FuncN> asyncAction(final ActionN action, final Scheduler scheduler) {
         return toAsync(action, scheduler);
@@ -1293,6 +1295,7 @@ public static FuncN> asyncAction(final ActionN action, final Sc
      * @param func the function to convert
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
+     * @see RxJava Wiki: asyncFunc()
      */
     public static  FuncN> asyncFunc(final FuncN func) {
         return toAsync(func);
@@ -1311,6 +1314,7 @@ public static  FuncN> asyncFunc(final FuncN func)
      * @param scheduler the scheduler used to call the {@code func}
      * @return a function that returns an Observable that executes the
      *         {@code func} and emits its returned value
+     * @see RxJava Wiki: asyncFunc()
      */
     public static  FuncN> asyncFunc(final FuncN func, final Scheduler scheduler) {
         return toAsync(func, scheduler);
@@ -1329,6 +1333,7 @@ public static  FuncN> asyncFunc(final FuncN func,
      * @param functionAsync the asynchronous function to run
      * @return an Observable that surfaces the result of the future
      * @see #startFuture(rx.util.functions.Func0, rx.Scheduler)
+     * @see RxJava Wiki: startFuture()
      */
     public static  Observable startFuture(Func0> functionAsync) {
         return OperationStartFuture.startFuture(functionAsync);
@@ -1345,6 +1350,7 @@ public static  Observable startFuture(Func0>
      * @param scheduler the scheduler where the completion of the Future is
      *                  awaited
      * @return an Observable that surfaces the result of the future
+     * @see RxJava Wiki: startFuture()
      */
     public static  Observable startFuture(Func0> functionAsync,
         Scheduler scheduler) {
@@ -1366,6 +1372,7 @@ public static  Observable startFuture(Func0>
      * @return the Observable emitting items produced by the asynchronous
      *         observer produced by the factory
      * @see #deferFuture(rx.util.functions.Func0, rx.Scheduler)
+     * @see RxJava Wiki: deferFuture()
      */
     public static  Observable deferFuture(Func0>> observableFactoryAsync) {
         return OperationDeferFuture.deferFuture(observableFactoryAsync);
@@ -1384,6 +1391,7 @@ public static  Observable deferFuture(Func0RxJava Wiki: deferFuture()
      */
     public static  Observable deferFuture(
         Func0>> observableFactoryAsync,
@@ -1405,6 +1413,7 @@ public static  Observable deferFuture(
      * @param onNext the action to call with each emitted element
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.util.functions.Action1, rx.Scheduler)
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
         Observable source,
@@ -1428,6 +1437,7 @@ public static  FutureTask forEachFuture(
      * @param onError the action to call when an exception is emitted
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.Scheduler)
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
         Observable source,
@@ -1453,6 +1463,7 @@ public static  FutureTask forEachFuture(
      * @param onCompleted the action to call when the source completes
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.util.functions.Action0, rx.Scheduler)
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
         Observable source,
@@ -1476,6 +1487,7 @@ public static  FutureTask forEachFuture(
      * @param scheduler the scheduler where the task will await the termination
      *                  of the for-each
      * @return the Future representing the entire for-each operation
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
         Observable source,
@@ -1501,6 +1513,7 @@ public static  FutureTask forEachFuture(
      * @param scheduler the scheduler where the task will await the termination
      *                  of the for-each
      * @return the Future representing the entire for-each operation
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
         Observable source,
@@ -1528,6 +1541,7 @@ public static  FutureTask forEachFuture(
      * @param scheduler the scheduler where the task will await the termination
      *                  of the for-each
      * @return the Future representing the entire for-each operation
+     * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
             Observable source,
@@ -1553,6 +1567,7 @@ public static  FutureTask forEachFuture(
      * @param result the result to emit to observers
      * @return an Observable that calls the given action and emits the given
      *         result when an Observer subscribes
+     * @see RxJava Wiki: fromAction()
      */
     public static  Observable fromAction(Action0 action, R result) {
         return fromAction(action, result, Schedulers.threadPoolForComputation());
@@ -1572,6 +1587,7 @@ public static  Observable fromAction(Action0 action, R result) {
      *         result when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
+     * @see RxJava Wiki: fromFunc0()
      */
     public static  Observable fromFunc0(Func0 function) {
         return fromFunc0(function, Schedulers.threadPoolForComputation());
@@ -1591,6 +1607,7 @@ public static  Observable fromFunc0(Func0 function) {
      *         result or Exception when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromFunc0(rx.util.functions.Func0) 
+     * @see RxJava Wiki: fromCallable()
      */
     public static  Observable fromCallable(Callable callable) {
         return fromCallable(callable, Schedulers.threadPoolForComputation());
@@ -1609,6 +1626,7 @@ public static  Observable fromCallable(Callable callable) {
      * @param result the result to emit to observers
      * @return an Observable that calls the given Runnable and emits the given
      *         result when an Observer subscribes
+     * @see RxJava Wiki: fromRunnable()
      */
     public static  Observable fromRunnable(final Runnable run, final R result) {
         return fromRunnable(run, result, Schedulers.threadPoolForComputation());
@@ -1627,6 +1645,7 @@ public static  Observable fromRunnable(final Runnable run, final R result)
      * @param result the result to emit to observers
      * @return an Observable that calls the given action and emits the given
      *         result when an Observer subscribes
+     * @see RxJava Wiki: fromAction()
      */
     public static  Observable fromAction(Action0 action, R result, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
@@ -1646,6 +1665,7 @@ public static  Observable fromAction(Action0 action, R result, Scheduler s
      *         result when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
+     * @see RxJava Wiki: fromFunc0()
      */
     public static  Observable fromFunc0(Func0 function, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromFunc0(function)).subscribeOn(scheduler);
@@ -1665,6 +1685,7 @@ public static  Observable fromFunc0(Func0 function, Scheduler
      *         result or Exception when an Observer subscribes
      * @see #start(rx.util.functions.Func0) 
      * @see #fromFunc0(rx.util.functions.Func0) 
+     * @see RxJava Wiki: fromCallable()
      */
     public static  Observable fromCallable(Callable callable, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromCallable(callable)).subscribeOn(scheduler);
@@ -1683,6 +1704,7 @@ public static  Observable fromCallable(Callable callable, Sch
      * @param result the result to emit to observers
      * @return an Observable that calls the given Runnable and emits the given
      *         result when an Observer subscribes
+     * @see RxJava Wiki: fromRunnable()
      */
     public static  Observable fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);

From 93d4e693194973c93e2f7e6fc0f4ca72208f8c24 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 20:30:30 -0800
Subject: [PATCH 161/441] Update Scheduler Tests for Recursion and Common
 Testing

---
 .../rx/schedulers/AbstractSchedulerTests.java | 273 ++++++++++++++++++
 .../CurrentThreadSchedulerTest.java           |  16 +-
 .../rx/schedulers/ExecutorSchedulerTests.java |   8 +-
 .../rx/schedulers/ImmediateSchedulerTest.java |  17 +-
 .../rx/schedulers/NewThreadSchedulerTest.java |  28 ++
 .../schedulers/SchedulerUnsubscribeTest.java  | 109 -------
 6 files changed, 331 insertions(+), 120 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
new file mode 100644
index 0000000000..bbd14b9812
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -0,0 +1,273 @@
+package rx.schedulers;
+
+import static org.junit.Assert.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.operators.SafeObservableSubscription;
+import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+import rx.util.functions.Func2;
+
+public abstract class AbstractSchedulerTests {
+
+    /**
+     * The scheduler to test
+     * 
+     * @return
+     */
+    protected abstract Scheduler getScheduler();
+
+    @Test
+    public void testUnsubscribeRecursiveScheduleWithStateAndFunc2() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
+        final AtomicInteger counter = new AtomicInteger();
+        Subscription s = getScheduler().schedule(0L, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                i++;
+                //                System.out.println("i: " + i);
+                if (i == 10) {
+                    latch.countDown();
+                    try {
+                        // wait for unsubscribe to finish so we are not racing it
+                        unsubscribeLatch.await();
+                    } catch (InterruptedException e) {
+                        // we expect the countDown if unsubscribe is not working
+                        // or to be interrupted if unsubscribe is successful since 
+                        // the unsubscribe will interrupt it as it is calling Future.cancel(true)
+                        // so we will ignore the stacktrace
+                    }
+                }
+
+                counter.incrementAndGet();
+                return innerScheduler.schedule(i, this);
+            }
+        });
+
+        latch.await();
+        s.unsubscribe();
+        unsubscribeLatch.countDown();
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        assertEquals(10, counter.get());
+    }
+
+    /**
+     * Bug report: https://github.com/Netflix/RxJava/issues/431
+     */
+    @Test
+    public void testUnSubscribeForScheduler() throws InterruptedException {
+
+        final AtomicInteger countReceived = new AtomicInteger();
+        final AtomicInteger countGenerated = new AtomicInteger();
+        final SafeObservableSubscription s = new SafeObservableSubscription();
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        s.wrap(Observable.interval(50, TimeUnit.MILLISECONDS)
+                .map(new Func1() {
+                    @Override
+                    public Long call(Long aLong) {
+                        countGenerated.incrementAndGet();
+                        return aLong;
+                    }
+                })
+                .subscribeOn(getScheduler())
+                .observeOn(getScheduler())
+                .subscribe(new Observer() {
+                    @Override
+                    public void onCompleted() {
+                        System.out.println("--- completed");
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        System.out.println("--- onError");
+                    }
+
+                    @Override
+                    public void onNext(Long args) {
+                        if (countReceived.incrementAndGet() == 2) {
+                            s.unsubscribe();
+                            latch.countDown();
+                        }
+                        System.out.println("==> Received " + args);
+                    }
+                }));
+
+        latch.await(1000, TimeUnit.MILLISECONDS);
+
+        System.out.println("----------- it thinks it is finished ------------------ ");
+        Thread.sleep(100);
+
+        assertEquals(2, countGenerated.get());
+    }
+
+    @Test
+    public void scheduleMultipleTasksOnOuterForSequentialExecution() throws InterruptedException {
+        final AtomicInteger countExecutions = new AtomicInteger();
+        final CountDownLatch latch = new CountDownLatch(1);
+        final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
+        final Func2 fInner = new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                countExecutions.incrementAndGet();
+                i++;
+                System.out.println("i: " + i);
+                if (i == 1000) {
+                    outerSubscription.unsubscribe();
+                    latch.countDown();
+                }
+                if (i < 10000) {
+                    return innerScheduler.schedule(i, this);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+        };
+
+        Func2 fOuter = new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                CompositeSubscription s = new CompositeSubscription();
+                s.add(innerScheduler.schedule(i, fInner));
+                s.add(innerScheduler.schedule(i, fInner));
+                return s;
+            }
+        };
+
+        outerSubscription.wrap(getScheduler().schedule(0L, fOuter));
+        latch.await();
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        System.out.println("Count: " + countExecutions.get());
+        // we unsubscribe on first to 1000 so we hit 1999 instead of 2000
+        assertEquals(1999, countExecutions.get());
+    }
+
+    @Test
+    public void unsubscribeWithFastProducerWithSlowConsumerCausingQueuing() throws InterruptedException {
+        final AtomicInteger countEmitted = new AtomicInteger();
+        final AtomicInteger countTaken = new AtomicInteger();
+        int value = Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer o) {
+                final BooleanSubscription s = BooleanSubscription.create();
+                Thread t = new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        int i = 1;
+                        while (!s.isUnsubscribed() && i <= 100) {
+                            System.out.println("onNext from fast producer: " + i);
+                            o.onNext(i++);
+                        }
+                        o.onCompleted();
+                    }
+                });
+                t.setDaemon(true);
+                t.start();
+                return s;
+            }
+        }).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                countEmitted.incrementAndGet();
+            }
+        }).doOnCompleted(new Action0() {
+
+            @Override
+            public void call() {
+                System.out.println("-------- Done Emitting from Source ---------");
+            }
+        }).observeOn(getScheduler()).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                System.out.println(">> onNext to slowConsumer pre-take: " + i);
+                //force it to be slower than the producer
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                countTaken.incrementAndGet();
+            }
+        }).take(10).toBlockingObservable().last();
+
+        // they will all emit because the consumer is running slow
+        assertEquals(100, countEmitted.get());
+        // number received after take (but take will filter any extra)
+        assertEquals(10, value);
+        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        // we expect only 10 to make it through the observeOn side
+        assertEquals(10, countTaken.get());
+    }
+
+    @Test(timeout = 8000)
+    public void recursionUsingFunc2() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        getScheduler().schedule(0L, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                i++;
+                if (i % 100000 == 0) {
+                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                }
+                if (i < 5000000L) {
+                    return innerScheduler.schedule(i, this);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+        });
+
+        latch.await();
+    }
+
+    @Test(timeout = 8000)
+    public void recursionUsingAction0() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        getScheduler().schedule(new Action1() {
+
+            private long i = 0;
+
+            @Override
+            public void call(Action0 self) {
+                i++;
+                if (i % 100000 == 0) {
+                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                }
+                if (i < 5000000L) {
+                    self.call();
+                } else {
+                    latch.countDown();
+                }
+            }
+        });
+
+        latch.await();
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
index b71d96af9e..7d7fbf4acf 100644
--- a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -22,9 +22,15 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.Scheduler;
 import rx.util.functions.Action0;
 
-public class CurrentThreadSchedulerTest {
+public class CurrentThreadSchedulerTest extends AbstractSchedulerTests {
+
+    @Override
+    protected Scheduler getScheduler() {
+        return CurrentThreadScheduler.getInstance();
+    }
 
     @Test
     public void testNestedActions() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index a4f306e436..fa825ac915 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -28,7 +28,13 @@
 import rx.util.functions.Action1;
 import rx.util.functions.Func2;
 
-public class ExecutorSchedulerTests {
+public class ExecutorSchedulerTests extends AbstractSchedulerTests {
+
+    @Override
+    protected Scheduler getScheduler() {
+        // this is an implementation of ExecutorScheduler
+        return Schedulers.threadPoolForComputation();
+    }
 
     @Test
     public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index bfece3af6c..2b81b3452b 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -20,9 +20,16 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.Scheduler;
 import rx.util.functions.Action0;
 
-public class ImmediateSchedulerTest {
+public class ImmediateSchedulerTest  extends AbstractSchedulerTests {
+
+    @Override
+    protected Scheduler getScheduler() {
+        return ImmediateScheduler.getInstance();
+    }
+
     @Test
     public void testNestedActions() {
         final ImmediateScheduler scheduler = new ImmediateScheduler();
diff --git a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
new file mode 100644
index 0000000000..a0e65582b6
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -0,0 +1,28 @@
+/**
+ * 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.schedulers;
+
+import rx.Scheduler;
+
+public class NewThreadSchedulerTest extends AbstractSchedulerTests {
+
+    @Override
+    protected Scheduler getScheduler() {
+        return NewThreadScheduler.getInstance();
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java
deleted file mode 100644
index ec51d7f977..0000000000
--- a/rxjava-core/src/test/java/rx/schedulers/SchedulerUnsubscribeTest.java
+++ /dev/null
@@ -1,109 +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.schedulers;
-
-import static org.junit.Assert.*;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-import rx.Scheduler;
-import rx.schedulers.Schedulers;
-import rx.operators.SafeObservableSubscription;
-import rx.util.functions.Func1;
-
-public class SchedulerUnsubscribeTest {
-
-    /**
-     * Bug report: https://github.com/Netflix/RxJava/issues/431
-     */
-    @Test
-    public void testUnsubscribeOfNewThread() throws InterruptedException {
-        testUnSubscribeForScheduler(Schedulers.newThread());
-    }
-
-    @Test
-    public void testUnsubscribeOfThreadPoolForIO() throws InterruptedException {
-        testUnSubscribeForScheduler(Schedulers.threadPoolForIO());
-    }
-
-    @Test
-    public void testUnsubscribeOfThreadPoolForComputation() throws InterruptedException {
-        testUnSubscribeForScheduler(Schedulers.threadPoolForComputation());
-    }
-
-    @Test
-    public void testUnsubscribeOfImmediateThread() throws InterruptedException {
-        testUnSubscribeForScheduler(Schedulers.immediate());
-    }
-
-    @Test
-    public void testUnsubscribeOfCurrentThread() throws InterruptedException {
-        testUnSubscribeForScheduler(Schedulers.currentThread());
-    }
-
-    public void testUnSubscribeForScheduler(Scheduler scheduler) throws InterruptedException {
-
-        final AtomicInteger countReceived = new AtomicInteger();
-        final AtomicInteger countGenerated = new AtomicInteger();
-        final SafeObservableSubscription s = new SafeObservableSubscription();
-        final CountDownLatch latch = new CountDownLatch(1);
-
-        s.wrap(Observable.interval(50, TimeUnit.MILLISECONDS)
-                .map(new Func1() {
-                    @Override
-                    public Long call(Long aLong) {
-                        System.out.println("generated " + aLong);
-                        countGenerated.incrementAndGet();
-                        return aLong;
-                    }
-                })
-                .subscribeOn(scheduler)
-                .observeOn(scheduler)
-                .subscribe(new Observer() {
-                    @Override
-                    public void onCompleted() {
-                        System.out.println("--- completed");
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        System.out.println("--- onError");
-                    }
-
-                    @Override
-                    public void onNext(Long args) {
-                        if (countReceived.incrementAndGet() == 2) {
-                            s.unsubscribe();
-                            latch.countDown();
-                        }
-                        System.out.println("==> Received " + args);
-                    }
-                }));
-
-        latch.await(1000, TimeUnit.MILLISECONDS);
-
-        System.out.println("----------- it thinks it is finished ------------------ ");
-        Thread.sleep(100);
-
-        assertEquals(2, countGenerated.get());
-    }
-}

From 0977f040a403bec9f5818247a9dc29fa649b2e19 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 20:30:43 -0800
Subject: [PATCH 162/441] Fix Deprecated Method Call

---
 rxjava-core/src/main/java/rx/Scheduler.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index b01872f226..a4cc789cd4 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -165,7 +165,7 @@ public Subscription call(final Scheduler scheduler, final Func2 parentAction) {
                     @Override
                     public void call() {
                         if (!parentSubscription.isUnsubscribed()) {
-                            childSubscription.setSubscription(scheduler.schedule(parentAction, parentAction));
+                            childSubscription.set(scheduler.schedule(parentAction, parentAction));
                         }
                     }
 

From fdbf5efb66bd1e2ad6039c13bfa53f9d6e3373ac Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 20:31:17 -0800
Subject: [PATCH 163/441] Memory Leak Tests

NewThreadScheduler is working, the other two are not so commented out for now until fixed.
---
 .../schedulers/TestRecursionMemoryUsage.java  | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java

diff --git a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
new file mode 100644
index 0000000000..730cde5e0b
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -0,0 +1,84 @@
+package rx.schedulers;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func2;
+
+/**
+ * Used for manual testing of memory leaks with recursive schedulers.
+ * 
+ */
+public class TestRecursionMemoryUsage {
+
+    public static void main(String args[]) {
+        usingFunc2(Schedulers.newThread());
+        usingAction0(Schedulers.newThread());
+//
+//        usingFunc2(Schedulers.currentThread());
+//        usingAction0(Schedulers.currentThread());
+
+//        usingFunc2(Schedulers.threadPoolForComputation());
+//        usingAction0(Schedulers.threadPoolForComputation());
+    }
+
+    protected static void usingFunc2(final Scheduler scheduler) {
+        System.out.println("************ usingFunc2: " + scheduler);
+        Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer o) {
+                return scheduler.schedule(0L, new Func2() {
+
+                    @Override
+                    public Subscription call(Scheduler innerScheduler, Long i) {
+                        i++;
+                        if (i % 500000 == 0) {
+                            System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                            o.onNext(i);
+                        }
+                        if (i == 100000000L) {
+                            o.onCompleted();
+                            return Subscriptions.empty();
+                        }
+
+                        return innerScheduler.schedule(i, this);
+                    }
+                });
+            }
+        }).toBlockingObservable().last();
+    }
+
+    protected static void usingAction0(final Scheduler scheduler) {
+        System.out.println("************ usingAction0: " + scheduler);
+        Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer o) {
+                return scheduler.schedule(new Action1() {
+
+                    private long i = 0;
+
+                    @Override
+                    public void call(Action0 self) {
+                        i++;
+                        if (i % 500000 == 0) {
+                            System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                            o.onNext(i);
+                        }
+                        if (i == 100000000L) {
+                            o.onCompleted();
+                            return;
+                        }
+                        self.call();
+                    }
+                });
+            }
+        }).toBlockingObservable().last();
+    }
+}

From b1d9c1cb62517f7cf3cbb64ac2c9bc2fd55d4f50 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 20:32:05 -0800
Subject: [PATCH 164/441] Fix Memory Leak in NewThreadScheduler Recursion

- the Action0 method did not have a leak
- the Func2 method on inner scheduler recursion did have a leak
---
 .../rx/schedulers/NewThreadScheduler.java     | 46 +++++++++++++++----
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 7e460923a6..bc6b971b18 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -25,7 +25,9 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 import rx.util.functions.Func2;
 
 /**
@@ -46,6 +48,7 @@ private NewThreadScheduler() {
 
     private static class EventLoopScheduler extends Scheduler {
         private final ExecutorService executor;
+        private final MultipleAssignmentSubscription childSubscription = new MultipleAssignmentSubscription();
 
         private EventLoopScheduler() {
             executor = Executors.newFixedThreadPool(1, new ThreadFactory() {
@@ -61,21 +64,30 @@ public Thread newThread(Runnable r) {
 
         @Override
         public  Subscription schedule(T state, Func2 action) {
+            CompositeSubscription s = new CompositeSubscription();
             final DiscardableAction discardableAction = new DiscardableAction(state, action);
-            // all subscriptions that may need to be unsubscribed
-            final CompositeSubscription subscription = new CompositeSubscription(discardableAction);
-            
+            s.add(discardableAction);
+
             final Scheduler _scheduler = this;
-            subscription.add(Subscriptions.from(executor.submit(new Runnable() {
+            s.add(Subscriptions.from(executor.submit(new Runnable() {
 
                 @Override
                 public void run() {
-                    Subscription s = discardableAction.call(_scheduler);
-                    subscription.add(s);
+                    discardableAction.call(_scheduler);
                 }
             })));
-            
-            return subscription;
+
+            // replace the EventLoopScheduler child subscription with this one
+            childSubscription.set(s);
+            /*
+             * If `schedule` is run concurrently instead of recursively then we'd lose subscriptions as the `childSubscription`
+             * only remembers the last one scheduled. However, the parent subscription will shutdown the entire EventLoopScheduler
+             * and the ExecutorService which will terminate all outstanding tasks so this childSubscription is actually somewhat
+             * superfluous for stopping and cleanup ... though childSubscription does ensure exactness as can be seen by
+             * the `testUnSubscribeForScheduler()` unit test which fails if the `childSubscription` does not exist.
+             */
+
+            return childSubscription;
         }
 
         @Override
@@ -103,12 +115,26 @@ public void run() {
             return subscription;
         }
 
+        private void shutdownNow() {
+            executor.shutdownNow();
+        }
+
     }
 
     @Override
     public  Subscription schedule(T state, Func2 action) {
-        EventLoopScheduler s = new EventLoopScheduler();
-        return s.schedule(state, action);
+        final EventLoopScheduler s = new EventLoopScheduler();
+        CompositeSubscription cs = new CompositeSubscription();
+        cs.add(s.schedule(state, action));
+        cs.add(Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                // shutdown the executor, all tasks queued to run and clean up resources
+                s.shutdownNow();
+            }
+        }));
+        return cs;
     }
 
     @Override

From 9f35594ec806672e7760873ba6837eac8f9b4454 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 21:06:37 -0800
Subject: [PATCH 165/441] Scheduler Unit Tests

- passing for all but ExecutorScheduler
---
 .../AbstractSchedulerConcurrencyTests.java    | 159 ++++++++++
 .../rx/schedulers/AbstractSchedulerTests.java | 295 +++++++++---------
 .../CurrentThreadSchedulerTest.java           | 122 --------
 .../rx/schedulers/ExecutorSchedulerTests.java |   2 +-
 .../rx/schedulers/ImmediateSchedulerTest.java |  57 +---
 .../rx/schedulers/NewThreadSchedulerTest.java |   2 +-
 6 files changed, 306 insertions(+), 331 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
new file mode 100644
index 0000000000..cd8f5907a2
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -0,0 +1,159 @@
+package rx.schedulers;
+
+import static org.junit.Assert.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.operators.SafeObservableSubscription;
+import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func2;
+
+/**
+ * Base tests for schedulers that involve threads (concurrency).
+ * 
+ * These can only run on Schedulers that launch threads since they expect async/concurrent behavior.
+ * 
+ * The Current/Immediate schedulers will not work with these tests.
+ */
+public abstract class AbstractSchedulerConcurrencyTests extends AbstractSchedulerTests {
+
+    @Test
+    public void testUnsubscribeRecursiveScheduleWithStateAndFunc2() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
+        final AtomicInteger counter = new AtomicInteger();
+        Subscription s = getScheduler().schedule(0L, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                i++;
+                //                System.out.println("i: " + i);
+                if (i == 10) {
+                    latch.countDown();
+                    try {
+                        // wait for unsubscribe to finish so we are not racing it
+                        unsubscribeLatch.await();
+                    } catch (InterruptedException e) {
+                        // we expect the countDown if unsubscribe is not working
+                        // or to be interrupted if unsubscribe is successful since 
+                        // the unsubscribe will interrupt it as it is calling Future.cancel(true)
+                        // so we will ignore the stacktrace
+                    }
+                }
+
+                counter.incrementAndGet();
+                return innerScheduler.schedule(i, this);
+            }
+        });
+
+        latch.await();
+        s.unsubscribe();
+        unsubscribeLatch.countDown();
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        assertEquals(10, counter.get());
+    }
+
+    @Test
+    public void scheduleMultipleTasksOnOuterForSequentialExecution() throws InterruptedException {
+        final AtomicInteger countExecutions = new AtomicInteger();
+        final CountDownLatch latch = new CountDownLatch(1);
+        final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
+        final Func2 fInner = new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                countExecutions.incrementAndGet();
+                i++;
+                System.out.println("i: " + i);
+                if (i == 1000) {
+                    outerSubscription.unsubscribe();
+                    latch.countDown();
+                }
+                if (i < 10000) {
+                    return innerScheduler.schedule(i, this);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+        };
+
+        Func2 fOuter = new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                CompositeSubscription s = new CompositeSubscription();
+                s.add(innerScheduler.schedule(i, fInner));
+                s.add(innerScheduler.schedule(i, fInner));
+                return s;
+            }
+        };
+
+        outerSubscription.wrap(getScheduler().schedule(0L, fOuter));
+        latch.await();
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        System.out.println("Count: " + countExecutions.get());
+        // we unsubscribe on first to 1000 so we hit 1999 instead of 2000
+        assertEquals(1999, countExecutions.get());
+    }
+
+    @Test(timeout = 8000)
+    public void recursionUsingFunc2() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        getScheduler().schedule(0L, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Long i) {
+                i++;
+                if (i % 100000 == 0) {
+                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                }
+                if (i < 5000000L) {
+                    return innerScheduler.schedule(i, this);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+        });
+
+        latch.await();
+    }
+
+    @Test(timeout = 8000)
+    public void recursionUsingAction0() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        getScheduler().schedule(new Action1() {
+
+            private long i = 0;
+
+            @Override
+            public void call(Action0 self) {
+                i++;
+                if (i % 100000 == 0) {
+                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
+                }
+                if (i < 5000000L) {
+                    self.call();
+                } else {
+                    latch.countDown();
+                }
+            }
+        });
+
+        latch.await();
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index bbd14b9812..921780f2b2 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -1,12 +1,14 @@
 package rx.schedulers;
 
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
+import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
@@ -15,63 +17,92 @@
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
 import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
+/**
+ * Base tests for all schedulers including Immediate/Current.
+ */
 public abstract class AbstractSchedulerTests {
 
     /**
      * The scheduler to test
-     * 
-     * @return
      */
     protected abstract Scheduler getScheduler();
 
     @Test
-    public void testUnsubscribeRecursiveScheduleWithStateAndFunc2() throws InterruptedException {
-        final CountDownLatch latch = new CountDownLatch(1);
-        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
-        final AtomicInteger counter = new AtomicInteger();
-        Subscription s = getScheduler().schedule(0L, new Func2() {
+    public final void unsubscribeWithFastProducerWithSlowConsumerCausingQueuing() throws InterruptedException {
+        final AtomicInteger countEmitted = new AtomicInteger();
+        final AtomicInteger countTaken = new AtomicInteger();
+        int value = Observable.create(new OnSubscribeFunc() {
 
             @Override
-            public Subscription call(Scheduler innerScheduler, Long i) {
-                i++;
-                //                System.out.println("i: " + i);
-                if (i == 10) {
-                    latch.countDown();
-                    try {
-                        // wait for unsubscribe to finish so we are not racing it
-                        unsubscribeLatch.await();
-                    } catch (InterruptedException e) {
-                        // we expect the countDown if unsubscribe is not working
-                        // or to be interrupted if unsubscribe is successful since 
-                        // the unsubscribe will interrupt it as it is calling Future.cancel(true)
-                        // so we will ignore the stacktrace
+            public Subscription onSubscribe(final Observer o) {
+                final BooleanSubscription s = BooleanSubscription.create();
+                Thread t = new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        int i = 1;
+                        while (!s.isUnsubscribed() && i <= 100) {
+                            System.out.println("onNext from fast producer: " + i);
+                            o.onNext(i++);
+                        }
+                        o.onCompleted();
                     }
-                }
+                });
+                t.setDaemon(true);
+                t.start();
+                return s;
+            }
+        }).doOnNext(new Action1() {
 
-                counter.incrementAndGet();
-                return innerScheduler.schedule(i, this);
+            @Override
+            public void call(Integer i) {
+                countEmitted.incrementAndGet();
             }
-        });
+        }).doOnCompleted(new Action0() {
+
+            @Override
+            public void call() {
+                System.out.println("-------- Done Emitting from Source ---------");
+            }
+        }).observeOn(getScheduler()).doOnNext(new Action1() {
 
-        latch.await();
-        s.unsubscribe();
-        unsubscribeLatch.countDown();
+            @Override
+            public void call(Integer i) {
+                System.out.println(">> onNext to slowConsumer pre-take: " + i);
+                //force it to be slower than the producer
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                countTaken.incrementAndGet();
+            }
+        }).take(10).toBlockingObservable().last();
+
+        if (getScheduler() instanceof CurrentThreadScheduler || getScheduler() instanceof ImmediateScheduler) {
+            // since there is no concurrency it will block and only emit as many as it can process
+            assertEquals(10, countEmitted.get());
+        } else {
+            // they will all emit because the consumer is running slow
+            assertEquals(100, countEmitted.get());
+        }
+        // number received after take (but take will filter any extra)
+        assertEquals(10, value);
+        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
         Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        assertEquals(10, counter.get());
+        // we expect only 10 to make it through the observeOn side
+        assertEquals(10, countTaken.get());
     }
 
     /**
      * Bug report: https://github.com/Netflix/RxJava/issues/431
      */
     @Test
-    public void testUnSubscribeForScheduler() throws InterruptedException {
+    public final void testUnSubscribeForScheduler() throws InterruptedException {
 
         final AtomicInteger countReceived = new AtomicInteger();
         final AtomicInteger countGenerated = new AtomicInteger();
@@ -118,156 +149,118 @@ public void onNext(Long args) {
     }
 
     @Test
-    public void scheduleMultipleTasksOnOuterForSequentialExecution() throws InterruptedException {
-        final AtomicInteger countExecutions = new AtomicInteger();
-        final CountDownLatch latch = new CountDownLatch(1);
-        final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
-        final Func2 fInner = new Func2() {
+    public final void testNestedActions() {
+        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
+
+        final Action0 firstStepStart = mock(Action0.class);
+        final Action0 firstStepEnd = mock(Action0.class);
+
+        final Action0 secondStepStart = mock(Action0.class);
+        final Action0 secondStepEnd = mock(Action0.class);
+
+        final Action0 thirdStepStart = mock(Action0.class);
+        final Action0 thirdStepEnd = mock(Action0.class);
 
+        final Action0 firstAction = new Action0() {
             @Override
-            public Subscription call(Scheduler innerScheduler, Long i) {
-                countExecutions.incrementAndGet();
-                i++;
-                System.out.println("i: " + i);
-                if (i == 1000) {
-                    outerSubscription.unsubscribe();
-                    latch.countDown();
-                }
-                if (i < 10000) {
-                    return innerScheduler.schedule(i, this);
-                } else {
-                    latch.countDown();
-                    return Subscriptions.empty();
-                }
+            public void call() {
+                firstStepStart.call();
+                firstStepEnd.call();
             }
         };
+        final Action0 secondAction = new Action0() {
+            @Override
+            public void call() {
+                secondStepStart.call();
+                scheduler.schedule(firstAction);
+                secondStepEnd.call();
 
-        Func2 fOuter = new Func2() {
-
+            }
+        };
+        final Action0 thirdAction = new Action0() {
             @Override
-            public Subscription call(Scheduler innerScheduler, Long i) {
-                CompositeSubscription s = new CompositeSubscription();
-                s.add(innerScheduler.schedule(i, fInner));
-                s.add(innerScheduler.schedule(i, fInner));
-                return s;
+            public void call() {
+                thirdStepStart.call();
+                scheduler.schedule(secondAction);
+                thirdStepEnd.call();
             }
         };
 
-        outerSubscription.wrap(getScheduler().schedule(0L, fOuter));
-        latch.await();
-        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        System.out.println("Count: " + countExecutions.get());
-        // we unsubscribe on first to 1000 so we hit 1999 instead of 2000
-        assertEquals(1999, countExecutions.get());
-    }
+        InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
 
-    @Test
-    public void unsubscribeWithFastProducerWithSlowConsumerCausingQueuing() throws InterruptedException {
-        final AtomicInteger countEmitted = new AtomicInteger();
-        final AtomicInteger countTaken = new AtomicInteger();
-        int value = Observable.create(new OnSubscribeFunc() {
+        scheduler.schedule(thirdAction);
 
-            @Override
-            public Subscription onSubscribe(final Observer o) {
-                final BooleanSubscription s = BooleanSubscription.create();
-                Thread t = new Thread(new Runnable() {
+        inOrder.verify(thirdStepStart, times(1)).call();
+        inOrder.verify(thirdStepEnd, times(1)).call();
+        inOrder.verify(secondStepStart, times(1)).call();
+        inOrder.verify(secondStepEnd, times(1)).call();
+        inOrder.verify(firstStepStart, times(1)).call();
+        inOrder.verify(firstStepEnd, times(1)).call();
+    }
 
-                    @Override
-                    public void run() {
-                        int i = 1;
-                        while (!s.isUnsubscribed() && i <= 100) {
-                            System.out.println("onNext from fast producer: " + i);
-                            o.onNext(i++);
-                        }
-                        o.onCompleted();
-                    }
-                });
-                t.setDaemon(true);
-                t.start();
-                return s;
-            }
-        }).doOnNext(new Action1() {
+    @Test
+    public final void testSequenceOfActions() {
+        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
 
-            @Override
-            public void call(Integer i) {
-                countEmitted.incrementAndGet();
-            }
-        }).doOnCompleted(new Action0() {
+        final Action0 first = mock(Action0.class);
+        final Action0 second = mock(Action0.class);
 
-            @Override
-            public void call() {
-                System.out.println("-------- Done Emitting from Source ---------");
-            }
-        }).observeOn(getScheduler()).doOnNext(new Action1() {
+        scheduler.schedule(first);
+        scheduler.schedule(second);
 
-            @Override
-            public void call(Integer i) {
-                System.out.println(">> onNext to slowConsumer pre-take: " + i);
-                //force it to be slower than the producer
-                try {
-                    Thread.sleep(10);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                countTaken.incrementAndGet();
-            }
-        }).take(10).toBlockingObservable().last();
+        verify(first, times(1)).call();
+        verify(second, times(1)).call();
 
-        // they will all emit because the consumer is running slow
-        assertEquals(100, countEmitted.get());
-        // number received after take (but take will filter any extra)
-        assertEquals(10, value);
-        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
-        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        // we expect only 10 to make it through the observeOn side
-        assertEquals(10, countTaken.get());
     }
 
-    @Test(timeout = 8000)
-    public void recursionUsingFunc2() throws InterruptedException {
-        final CountDownLatch latch = new CountDownLatch(1);
-        getScheduler().schedule(0L, new Func2() {
+    @Test
+    public final void testSequenceOfDelayedActions() {
+        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
+
+        final Action0 first = mock(Action0.class);
+        final Action0 second = mock(Action0.class);
 
+        scheduler.schedule(new Action0() {
             @Override
-            public Subscription call(Scheduler innerScheduler, Long i) {
-                i++;
-                if (i % 100000 == 0) {
-                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
-                }
-                if (i < 5000000L) {
-                    return innerScheduler.schedule(i, this);
-                } else {
-                    latch.countDown();
-                    return Subscriptions.empty();
-                }
+            public void call() {
+                scheduler.schedule(first, 30, TimeUnit.MILLISECONDS);
+                scheduler.schedule(second, 10, TimeUnit.MILLISECONDS);
             }
         });
 
-        latch.await();
+        InOrder inOrder = inOrder(first, second);
+
+        inOrder.verify(second, times(1)).call();
+        inOrder.verify(first, times(1)).call();
+
     }
 
-    @Test(timeout = 8000)
-    public void recursionUsingAction0() throws InterruptedException {
-        final CountDownLatch latch = new CountDownLatch(1);
-        getScheduler().schedule(new Action1() {
+    @Test
+    public final void testMixOfDelayedAndNonDelayedActions() {
+        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
 
-            private long i = 0;
+        final Action0 first = mock(Action0.class);
+        final Action0 second = mock(Action0.class);
+        final Action0 third = mock(Action0.class);
+        final Action0 fourth = mock(Action0.class);
 
+        scheduler.schedule(new Action0() {
             @Override
-            public void call(Action0 self) {
-                i++;
-                if (i % 100000 == 0) {
-                    System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
-                }
-                if (i < 5000000L) {
-                    self.call();
-                } else {
-                    latch.countDown();
-                }
+            public void call() {
+                scheduler.schedule(first);
+                scheduler.schedule(second, 300, TimeUnit.MILLISECONDS);
+                scheduler.schedule(third, 100, TimeUnit.MILLISECONDS);
+                scheduler.schedule(fourth);
             }
         });
 
-        latch.await();
+        InOrder inOrder = inOrder(first, second, third, fourth);
+
+        inOrder.verify(first, times(1)).call();
+        inOrder.verify(fourth, times(1)).call();
+        inOrder.verify(third, times(1)).call();
+        inOrder.verify(second, times(1)).call();
+
     }
 
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
index 7d7fbf4acf..961617bbd8 100644
--- a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
@@ -15,15 +15,7 @@
  */
 package rx.schedulers;
 
-import static org.mockito.Mockito.*;
-
-import java.util.concurrent.TimeUnit;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-
 import rx.Scheduler;
-import rx.util.functions.Action0;
 
 public class CurrentThreadSchedulerTest extends AbstractSchedulerTests {
 
@@ -32,118 +24,4 @@ protected Scheduler getScheduler() {
         return CurrentThreadScheduler.getInstance();
     }
 
-    @Test
-    public void testNestedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
-
-        final Action0 firstStepStart = mock(Action0.class);
-        final Action0 firstStepEnd = mock(Action0.class);
-
-        final Action0 secondStepStart = mock(Action0.class);
-        final Action0 secondStepEnd = mock(Action0.class);
-
-        final Action0 thirdStepStart = mock(Action0.class);
-        final Action0 thirdStepEnd = mock(Action0.class);
-
-        final Action0 firstAction = new Action0() {
-            @Override
-            public void call() {
-                firstStepStart.call();
-                firstStepEnd.call();
-            }
-        };
-        final Action0 secondAction = new Action0() {
-            @Override
-            public void call() {
-                secondStepStart.call();
-                scheduler.schedule(firstAction);
-                secondStepEnd.call();
-
-            }
-        };
-        final Action0 thirdAction = new Action0() {
-            @Override
-            public void call() {
-                thirdStepStart.call();
-                scheduler.schedule(secondAction);
-                thirdStepEnd.call();
-            }
-        };
-
-        InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
-
-        scheduler.schedule(thirdAction);
-
-        inOrder.verify(thirdStepStart, times(1)).call();
-        inOrder.verify(thirdStepEnd, times(1)).call();
-        inOrder.verify(secondStepStart, times(1)).call();
-        inOrder.verify(secondStepEnd, times(1)).call();
-        inOrder.verify(firstStepStart, times(1)).call();
-        inOrder.verify(firstStepEnd, times(1)).call();
-    }
-
-    @Test
-    public void testSequenceOfActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
-
-        final Action0 first = mock(Action0.class);
-        final Action0 second = mock(Action0.class);
-
-        scheduler.schedule(first);
-        scheduler.schedule(second);
-
-        verify(first, times(1)).call();
-        verify(second, times(1)).call();
-
-    }
-
-    @Test
-    public void testSequenceOfDelayedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
-
-        final Action0 first = mock(Action0.class);
-        final Action0 second = mock(Action0.class);
-
-        scheduler.schedule(new Action0() {
-            @Override
-            public void call() {
-                scheduler.schedule(first, 30, TimeUnit.MILLISECONDS);
-                scheduler.schedule(second, 10, TimeUnit.MILLISECONDS);
-            }
-        });
-
-        InOrder inOrder = inOrder(first, second);
-
-        inOrder.verify(second, times(1)).call();
-        inOrder.verify(first, times(1)).call();
-
-    }
-
-    @Test
-    public void testMixOfDelayedAndNonDelayedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
-
-        final Action0 first = mock(Action0.class);
-        final Action0 second = mock(Action0.class);
-        final Action0 third = mock(Action0.class);
-        final Action0 fourth = mock(Action0.class);
-
-        scheduler.schedule(new Action0() {
-            @Override
-            public void call() {
-                scheduler.schedule(first);
-                scheduler.schedule(second, 300, TimeUnit.MILLISECONDS);
-                scheduler.schedule(third, 100, TimeUnit.MILLISECONDS);
-                scheduler.schedule(fourth);
-            }
-        });
-
-        InOrder inOrder = inOrder(first, second, third, fourth);
-
-        inOrder.verify(first, times(1)).call();
-        inOrder.verify(fourth, times(1)).call();
-        inOrder.verify(third, times(1)).call();
-        inOrder.verify(second, times(1)).call();
-
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index fa825ac915..d065475232 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -28,7 +28,7 @@
 import rx.util.functions.Action1;
 import rx.util.functions.Func2;
 
-public class ExecutorSchedulerTests extends AbstractSchedulerTests {
+public class ExecutorSchedulerTests extends AbstractSchedulerConcurrencyTests {
 
     @Override
     protected Scheduler getScheduler() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index 2b81b3452b..ff3e6c138b 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -15,68 +15,13 @@
  */
 package rx.schedulers;
 
-import static org.mockito.Mockito.*;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-
 import rx.Scheduler;
-import rx.util.functions.Action0;
 
-public class ImmediateSchedulerTest  extends AbstractSchedulerTests {
+public class ImmediateSchedulerTest extends AbstractSchedulerTests {
 
     @Override
     protected Scheduler getScheduler() {
         return ImmediateScheduler.getInstance();
     }
 
-    @Test
-    public void testNestedActions() {
-        final ImmediateScheduler scheduler = new ImmediateScheduler();
-
-        final Action0 firstStepStart = mock(Action0.class);
-        final Action0 firstStepEnd = mock(Action0.class);
-
-        final Action0 secondStepStart = mock(Action0.class);
-        final Action0 secondStepEnd = mock(Action0.class);
-
-        final Action0 thirdStepStart = mock(Action0.class);
-        final Action0 thirdStepEnd = mock(Action0.class);
-
-        final Action0 firstAction = new Action0() {
-            @Override
-            public void call() {
-                firstStepStart.call();
-                firstStepEnd.call();
-            }
-        };
-        final Action0 secondAction = new Action0() {
-            @Override
-            public void call() {
-                secondStepStart.call();
-                scheduler.schedule(firstAction);
-                secondStepEnd.call();
-
-            }
-        };
-        final Action0 thirdAction = new Action0() {
-            @Override
-            public void call() {
-                thirdStepStart.call();
-                scheduler.schedule(secondAction);
-                thirdStepEnd.call();
-            }
-        };
-
-        InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
-
-        scheduler.schedule(thirdAction);
-
-        inOrder.verify(thirdStepStart, times(1)).call();
-        inOrder.verify(secondStepStart, times(1)).call();
-        inOrder.verify(firstStepStart, times(1)).call();
-        inOrder.verify(firstStepEnd, times(1)).call();
-        inOrder.verify(secondStepEnd, times(1)).call();
-        inOrder.verify(thirdStepEnd, times(1)).call();
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index a0e65582b6..eaf5855e6c 100644
--- a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -18,7 +18,7 @@
 
 import rx.Scheduler;
 
-public class NewThreadSchedulerTest extends AbstractSchedulerTests {
+public class NewThreadSchedulerTest extends AbstractSchedulerConcurrencyTests {
 
     @Override
     protected Scheduler getScheduler() {

From 5b2dab3ad9b2226f5be972f6b4035f82360d1199 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 22:35:49 -0800
Subject: [PATCH 166/441] ExecutorScheduler Memory Leak Fix

- new InnerExecutorScheduler and childSubscription
- improvements to unit tests
---
 .../java/rx/schedulers/ExecutorScheduler.java | 145 +++++++++++++++---
 .../rx/schedulers/NewThreadScheduler.java     |   8 +
 .../AbstractSchedulerConcurrencyTests.java    |  71 ++++-----
 .../schedulers/TestRecursionMemoryUsage.java  |   6 +-
 4 files changed, 162 insertions(+), 68 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index 563e609612..443056438b 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -25,6 +25,7 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func2;
 
@@ -68,9 +69,10 @@ public void run() {
     @Override
     public  Subscription schedule(final T state, final Func2 action, long delayTime, TimeUnit unit) {
         final DiscardableAction discardableAction = new DiscardableAction(state, action);
-        final Scheduler _scheduler = this;
+        final InnerExecutorScheduler _scheduler = new InnerExecutorScheduler(executor);
+
         // all subscriptions that may need to be unsubscribed
-        final CompositeSubscription subscription = new CompositeSubscription(discardableAction);
+        final CompositeSubscription subscription = new CompositeSubscription(discardableAction, _scheduler);
 
         if (executor instanceof ScheduledExecutorService) {
             // we are a ScheduledExecutorService so can do proper scheduling
@@ -78,9 +80,7 @@ public  Subscription schedule(final T state, final Func2 Subscription schedule(T state, Func2 action) {
+        CompositeSubscription s = new CompositeSubscription();
         final DiscardableAction discardableAction = new DiscardableAction(state, action);
-        final Scheduler _scheduler = this;
-        // all subscriptions that may need to be unsubscribed
-        final CompositeSubscription subscription = new CompositeSubscription(discardableAction);
+        s.add(discardableAction);
+
+        final InnerExecutorScheduler _scheduler = new InnerExecutorScheduler(executor);
+        s.add(_scheduler);
 
-        // work to be done on a thread
-        Runnable r = new Runnable() {
+        s.add(execute(executor, new Runnable() {
             @Override
             public void run() {
-                Subscription s = discardableAction.call(_scheduler);
-                // add the subscription to the CompositeSubscription so it is unsubscribed
-                subscription.add(s);
+                discardableAction.call(_scheduler);
             }
-        };
+        }));
+
+        return s;
+    }
 
+    /**
+     * Execute on the given Executor and retrieve a Subscription
+     * 
+     * @param executor
+     * @param r
+     * @return
+     */
+    private static Subscription execute(Executor executor, Runnable r) {
         // submit for immediate execution
         if (executor instanceof ExecutorService) {
             // we are an ExecutorService so get a Future back that supports unsubscribe
             Future f = ((ExecutorService) executor).submit(r);
             // add the Future as a subscription so we can cancel the scheduled action if an unsubscribe happens
-            subscription.add(Subscriptions.from(f));
+            return Subscriptions.from(f);
         } else {
             // we are the lowest common denominator so can't unsubscribe once we execute
             executor.execute(r);
+            return Subscriptions.empty();
         }
+    }
 
-        return subscription;
+    private static class InnerExecutorScheduler extends Scheduler implements Subscription {
+
+        private final MultipleAssignmentSubscription childSubscription = new MultipleAssignmentSubscription();
+        private final Executor executor;
+
+        InnerExecutorScheduler(Executor executor) {
+            this.executor = executor;
+        }
+
+        @Override
+        public  Subscription schedule(T state, Func2 action) {
+            if(childSubscription.isUnsubscribed()) {
+                return childSubscription;
+            }
+            
+            CompositeSubscription s = new CompositeSubscription();
+            final DiscardableAction discardableAction = new DiscardableAction(state, action);
+            s.add(discardableAction);
+
+            final Scheduler _scheduler = this;
+
+            s.add(execute(executor, new Runnable() {
+
+                @Override
+                public void run() {
+                    discardableAction.call(_scheduler);
+                }
+            }));
+
+            // replace the InnerExecutorScheduler child subscription with this one
+            childSubscription.set(s);
+            /*
+             * TODO: Consider what will happen if `schedule` is run concurrently instead of recursively
+             * and we lose subscriptions as the `childSubscription` only remembers the last one scheduled.
+             * 
+             * Not obvious that this should ever happen. Can it?
+             * 
+             * benjchristensen => Haven't been able to come up with a valid test case to prove this as an issue
+             * so it may not be.
+             */
+
+            return childSubscription;
+        }
+
+        @Override
+        public  Subscription schedule(final T state, final Func2 action, long delayTime, TimeUnit unit) {
+            if(childSubscription.isUnsubscribed()) {
+                return childSubscription;
+            }
+            
+            CompositeSubscription s = new CompositeSubscription();
+            final DiscardableAction discardableAction = new DiscardableAction(state, action);
+            s.add(discardableAction);
+
+            final Scheduler _scheduler = this;
+
+            if (executor instanceof ScheduledExecutorService) {
+                // we are a ScheduledExecutorService so can do proper scheduling
+                ScheduledFuture f = ((ScheduledExecutorService) executor).schedule(new Runnable() {
+                    @Override
+                    public void run() {
+                        // when the delay has passed we now do the work on the actual scheduler
+                        discardableAction.call(_scheduler);
+                    }
+                }, delayTime, unit);
+                // replace the InnerExecutorScheduler child subscription with this one
+                childSubscription.set(Subscriptions.from(f));
+            } else {
+                // we are not a ScheduledExecutorService so can't directly schedule
+                if (delayTime == 0) {
+                    // no delay so put on the thread-pool right now
+                    return schedule(state, action);
+                } else {
+                    // there is a delay and this isn't a ScheduledExecutorService so we'll use a system-wide ScheduledExecutorService
+                    // to handle the scheduling and once it's ready then execute on this Executor
+                    ScheduledFuture f = GenericScheduledExecutorService.getInstance().schedule(new Runnable() {
+
+                        @Override
+                        public void run() {
+                            // now execute on the real Executor (by using the other overload that schedules for immediate execution)
+                            _scheduler.schedule(state, action);
+                        }
+                    }, delayTime, unit);
+                    // replace the InnerExecutorScheduler child subscription with this one
+                    childSubscription.set(Subscriptions.from(f));
+                }
+            }
+            return childSubscription;
+        }
+
+        @Override
+        public void unsubscribe() {
+            childSubscription.unsubscribe();
+        }
 
     }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index bc6b971b18..a175fe608f 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -64,6 +64,10 @@ public Thread newThread(Runnable r) {
 
         @Override
         public  Subscription schedule(T state, Func2 action) {
+            if (childSubscription.isUnsubscribed()) {
+                return childSubscription;
+            }
+
             CompositeSubscription s = new CompositeSubscription();
             final DiscardableAction discardableAction = new DiscardableAction(state, action);
             s.add(discardableAction);
@@ -92,6 +96,10 @@ public void run() {
 
         @Override
         public  Subscription schedule(final T state, final Func2 action, final long delayTime, final TimeUnit unit) {
+            if (childSubscription.isUnsubscribed()) {
+                return childSubscription;
+            }
+
             // we will use the system scheduler since it doesn't make sense to launch a new Thread and then sleep
             // we will instead schedule the event then launch the thread after the delay has passed
             final Scheduler _scheduler = this;
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index cd8f5907a2..8fb00c6553 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -3,17 +3,14 @@
 import static org.junit.Assert.*;
 
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
-import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
@@ -34,12 +31,11 @@ public void testUnsubscribeRecursiveScheduleWithStateAndFunc2() throws Interrupt
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        Subscription s = getScheduler().schedule(0L, new Func2() {
+        Subscription s = getScheduler().schedule(1L, new Func2() {
 
             @Override
             public Subscription call(Scheduler innerScheduler, Long i) {
-                i++;
-                //                System.out.println("i: " + i);
+                System.out.println("Run: " + i);
                 if (i == 10) {
                     latch.countDown();
                     try {
@@ -54,7 +50,7 @@ public Subscription call(Scheduler innerScheduler, Long i) {
                 }
 
                 counter.incrementAndGet();
-                return innerScheduler.schedule(i, this);
+                return innerScheduler.schedule(i + 1, this);
             }
         });
 
@@ -66,62 +62,51 @@ public Subscription call(Scheduler innerScheduler, Long i) {
     }
 
     @Test
-    public void scheduleMultipleTasksOnOuterForSequentialExecution() throws InterruptedException {
-        final AtomicInteger countExecutions = new AtomicInteger();
+    public void testUnsubscribeRecursiveScheduleWithStateAndFunc2AndDelay() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
-        final Func2 fInner = new Func2() {
+        final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
+        final AtomicInteger counter = new AtomicInteger();
+        Subscription s = getScheduler().schedule(1L, new Func2() {
 
             @Override
             public Subscription call(Scheduler innerScheduler, Long i) {
-                countExecutions.incrementAndGet();
-                i++;
-                System.out.println("i: " + i);
-                if (i == 1000) {
-                    outerSubscription.unsubscribe();
-                    latch.countDown();
-                }
-                if (i < 10000) {
-                    return innerScheduler.schedule(i, this);
-                } else {
+                if (i == 10) {
                     latch.countDown();
-                    return Subscriptions.empty();
+                    try {
+                        // wait for unsubscribe to finish so we are not racing it
+                        unsubscribeLatch.await();
+                    } catch (InterruptedException e) {
+                        // we expect the countDown if unsubscribe is not working
+                        // or to be interrupted if unsubscribe is successful since 
+                        // the unsubscribe will interrupt it as it is calling Future.cancel(true)
+                        // so we will ignore the stacktrace
+                    }
                 }
-            }
-        };
-
-        Func2 fOuter = new Func2() {
 
-            @Override
-            public Subscription call(Scheduler innerScheduler, Long i) {
-                CompositeSubscription s = new CompositeSubscription();
-                s.add(innerScheduler.schedule(i, fInner));
-                s.add(innerScheduler.schedule(i, fInner));
-                return s;
+                counter.incrementAndGet();
+                return innerScheduler.schedule(i + 1, this, 10, TimeUnit.MILLISECONDS);
             }
-        };
+        }, 10, TimeUnit.MILLISECONDS);
 
-        outerSubscription.wrap(getScheduler().schedule(0L, fOuter));
         latch.await();
+        s.unsubscribe();
+        unsubscribeLatch.countDown();
         Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        System.out.println("Count: " + countExecutions.get());
-        // we unsubscribe on first to 1000 so we hit 1999 instead of 2000
-        assertEquals(1999, countExecutions.get());
+        assertEquals(10, counter.get());
     }
 
     @Test(timeout = 8000)
     public void recursionUsingFunc2() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        getScheduler().schedule(0L, new Func2() {
+        getScheduler().schedule(1L, new Func2() {
 
             @Override
             public Subscription call(Scheduler innerScheduler, Long i) {
-                i++;
                 if (i % 100000 == 0) {
                     System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
                 }
-                if (i < 5000000L) {
-                    return innerScheduler.schedule(i, this);
+                if (i < 1000000L) {
+                    return innerScheduler.schedule(i + 1, this);
                 } else {
                     latch.countDown();
                     return Subscriptions.empty();
@@ -145,7 +130,7 @@ public void call(Action0 self) {
                 if (i % 100000 == 0) {
                     System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
                 }
-                if (i < 5000000L) {
+                if (i < 1000000L) {
                     self.call();
                 } else {
                     latch.countDown();
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
index 730cde5e0b..294193b167 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -19,12 +19,12 @@ public class TestRecursionMemoryUsage {
     public static void main(String args[]) {
         usingFunc2(Schedulers.newThread());
         usingAction0(Schedulers.newThread());
-//
+
 //        usingFunc2(Schedulers.currentThread());
 //        usingAction0(Schedulers.currentThread());
 
-//        usingFunc2(Schedulers.threadPoolForComputation());
-//        usingAction0(Schedulers.threadPoolForComputation());
+        usingFunc2(Schedulers.threadPoolForComputation());
+        usingAction0(Schedulers.threadPoolForComputation());
     }
 
     protected static void usingFunc2(final Scheduler scheduler) {

From 9a94fd278693e098837dddce222a732c1a57f532 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 30 Dec 2013 23:33:55 -0800
Subject: [PATCH 167/441] CurrentThreadScheduler Memory Leak Fixed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Current/Immediate/NewThread/Executor Schedulers are passing unit tests
- Current/NewThread/Executor Schedulers do not leak memory on the recursion test (Immediate can’t be used for recursion otherwise it stack overflows)
---
 .../rx/schedulers/CurrentThreadScheduler.java |  56 ++++--
 .../AbstractSchedulerConcurrencyTests.java    |  53 +++++-
 .../rx/schedulers/AbstractSchedulerTests.java | 170 ++++++++++++------
 .../rx/schedulers/ImmediateSchedulerTest.java |  23 +++
 .../schedulers/TestRecursionMemoryUsage.java  |   4 +-
 5 files changed, 234 insertions(+), 72 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
index d1550a2422..67d66aa4aa 100644
--- a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
@@ -17,10 +17,12 @@
 
 import java.util.PriorityQueue;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.util.functions.Func2;
 
 /**
@@ -28,6 +30,7 @@
  */
 public class CurrentThreadScheduler extends Scheduler {
     private static final CurrentThreadScheduler INSTANCE = new CurrentThreadScheduler();
+    private static final AtomicLong counter = new AtomicLong(0);
 
     public static CurrentThreadScheduler getInstance() {
         return INSTANCE;
@@ -38,25 +41,27 @@ public static CurrentThreadScheduler getInstance() {
     /* package accessible for unit tests */CurrentThreadScheduler() {
     }
 
-    private final AtomicInteger counter = new AtomicInteger(0);
-
     @Override
     public  Subscription schedule(T state, Func2 action) {
+        // immediately move to the InnerCurrentThreadScheduler
+        InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
         DiscardableAction discardableAction = new DiscardableAction(state, action);
-        enqueue(discardableAction, now());
-        return discardableAction;
+        enqueue(innerScheduler, discardableAction, now());
+        return innerScheduler;
     }
 
     @Override
     public  Subscription schedule(T state, Func2 action, long dueTime, TimeUnit unit) {
         long execTime = now() + unit.toMillis(dueTime);
 
+        // immediately move to the InnerCurrentThreadScheduler
+        InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
         DiscardableAction discardableAction = new DiscardableAction(state, new SleepingAction(action, this, execTime));
-        enqueue(discardableAction, execTime);
+        enqueue(innerScheduler, discardableAction, execTime);
         return discardableAction;
     }
 
-    private void enqueue(DiscardableAction action, long execTime) {
+    private static void enqueue(Scheduler scheduler, DiscardableAction action, long execTime) {
         PriorityQueue queue = QUEUE.get();
         boolean exec = queue == null;
 
@@ -69,19 +74,50 @@ private void enqueue(DiscardableAction action, long execTime) {
 
         if (exec) {
             while (!queue.isEmpty()) {
-                queue.poll().action.call(this);
+                queue.poll().action.call(scheduler);
             }
 
             QUEUE.set(null);
         }
     }
 
+    private static class InnerCurrentThreadScheduler extends Scheduler implements Subscription {
+        private final MultipleAssignmentSubscription childSubscription = new MultipleAssignmentSubscription();
+
+        @Override
+        public  Subscription schedule(T state, Func2 action) {
+            DiscardableAction discardableAction = new DiscardableAction(state, action);
+            childSubscription.set(discardableAction);
+            enqueue(this, discardableAction, now());
+            return childSubscription;
+        }
+
+        @Override
+        public  Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) {
+            long execTime = now() + unit.toMillis(delayTime);
+
+            DiscardableAction discardableAction = new DiscardableAction(state, action);
+            childSubscription.set(discardableAction);
+            enqueue(this, discardableAction, execTime);
+            return childSubscription;
+        }
+
+        @Override
+        public void unsubscribe() {
+            childSubscription.unsubscribe();
+        }
+
+    }
+
+    /**
+     * Use time to sort items so delayed actions are sorted to their appropriate position in the queue.
+     */
     private static class TimedAction implements Comparable {
         final DiscardableAction action;
         final Long execTime;
-        final Integer count; // In case if time between enqueueing took less than 1ms
+        final Long count; // In case if time between enqueueing took less than 1ms
 
-        private TimedAction(DiscardableAction action, Long execTime, Integer count) {
+        private TimedAction(DiscardableAction action, Long execTime, Long count) {
             this.action = action;
             this.execTime = execTime;
             this.count = count;
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 8fb00c6553..6602d5071d 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -8,13 +8,15 @@
 
 import org.junit.Test;
 
+import rx.Observable;
+import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
-import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 /**
@@ -26,6 +28,55 @@
  */
 public abstract class AbstractSchedulerConcurrencyTests extends AbstractSchedulerTests {
 
+    /**
+     * Bug report: https://github.com/Netflix/RxJava/issues/431
+     */
+    @Test
+    public final void testUnSubscribeForScheduler() throws InterruptedException {
+        final AtomicInteger countReceived = new AtomicInteger();
+        final AtomicInteger countGenerated = new AtomicInteger();
+        final SafeObservableSubscription s = new SafeObservableSubscription();
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        s.wrap(Observable.interval(50, TimeUnit.MILLISECONDS)
+                .map(new Func1() {
+                    @Override
+                    public Long call(Long aLong) {
+                        countGenerated.incrementAndGet();
+                        return aLong;
+                    }
+                })
+                .subscribeOn(getScheduler())
+                .observeOn(getScheduler())
+                .subscribe(new Observer() {
+                    @Override
+                    public void onCompleted() {
+                        System.out.println("--- completed");
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        System.out.println("--- onError");
+                    }
+
+                    @Override
+                    public void onNext(Long args) {
+                        if (countReceived.incrementAndGet() == 2) {
+                            s.unsubscribe();
+                            latch.countDown();
+                        }
+                        System.out.println("==> Received " + args);
+                    }
+                }));
+
+        latch.await(1000, TimeUnit.MILLISECONDS);
+
+        System.out.println("----------- it thinks it is finished ------------------ ");
+        Thread.sleep(100);
+
+        assertEquals(2, countGenerated.get());
+    }
+
     @Test
     public void testUnsubscribeRecursiveScheduleWithStateAndFunc2() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 921780f2b2..508727bc12 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -15,11 +15,11 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.operators.SafeObservableSubscription;
 import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.util.functions.Func2;
 
 /**
  * Base tests for all schedulers including Immediate/Current.
@@ -98,60 +98,11 @@ public void call(Integer i) {
         assertEquals(10, countTaken.get());
     }
 
-    /**
-     * Bug report: https://github.com/Netflix/RxJava/issues/431
-     */
     @Test
-    public final void testUnSubscribeForScheduler() throws InterruptedException {
-
-        final AtomicInteger countReceived = new AtomicInteger();
-        final AtomicInteger countGenerated = new AtomicInteger();
-        final SafeObservableSubscription s = new SafeObservableSubscription();
+    public void testNestedActions() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
         final CountDownLatch latch = new CountDownLatch(1);
 
-        s.wrap(Observable.interval(50, TimeUnit.MILLISECONDS)
-                .map(new Func1() {
-                    @Override
-                    public Long call(Long aLong) {
-                        countGenerated.incrementAndGet();
-                        return aLong;
-                    }
-                })
-                .subscribeOn(getScheduler())
-                .observeOn(getScheduler())
-                .subscribe(new Observer() {
-                    @Override
-                    public void onCompleted() {
-                        System.out.println("--- completed");
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        System.out.println("--- onError");
-                    }
-
-                    @Override
-                    public void onNext(Long args) {
-                        if (countReceived.incrementAndGet() == 2) {
-                            s.unsubscribe();
-                            latch.countDown();
-                        }
-                        System.out.println("==> Received " + args);
-                    }
-                }));
-
-        latch.await(1000, TimeUnit.MILLISECONDS);
-
-        System.out.println("----------- it thinks it is finished ------------------ ");
-        Thread.sleep(100);
-
-        assertEquals(2, countGenerated.get());
-    }
-
-    @Test
-    public final void testNestedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
-
         final Action0 firstStepStart = mock(Action0.class);
         final Action0 firstStepEnd = mock(Action0.class);
 
@@ -166,6 +117,7 @@ public final void testNestedActions() {
             public void call() {
                 firstStepStart.call();
                 firstStepEnd.call();
+                latch.countDown();
             }
         };
         final Action0 secondAction = new Action0() {
@@ -189,6 +141,8 @@ public void call() {
         InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
 
         scheduler.schedule(thirdAction);
+        
+        latch.await();
 
         inOrder.verify(thirdStepStart, times(1)).call();
         inOrder.verify(thirdStepEnd, times(1)).call();
@@ -199,14 +153,24 @@ public void call() {
     }
 
     @Test
-    public final void testSequenceOfActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
+    public final void testSequenceOfActions() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
 
+        final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
         final Action0 second = mock(Action0.class);
 
         scheduler.schedule(first);
         scheduler.schedule(second);
+        scheduler.schedule(new Action0() {
+
+            @Override
+            public void call() {
+                latch.countDown();
+            }
+        });
+
+        latch.await();
 
         verify(first, times(1)).call();
         verify(second, times(1)).call();
@@ -214,9 +178,10 @@ public final void testSequenceOfActions() {
     }
 
     @Test
-    public final void testSequenceOfDelayedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
+    public void testSequenceOfDelayedActions() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
 
+        final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
         final Action0 second = mock(Action0.class);
 
@@ -225,9 +190,17 @@ public final void testSequenceOfDelayedActions() {
             public void call() {
                 scheduler.schedule(first, 30, TimeUnit.MILLISECONDS);
                 scheduler.schedule(second, 10, TimeUnit.MILLISECONDS);
+                scheduler.schedule(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+                }, 40, TimeUnit.MILLISECONDS);
             }
         });
 
+        latch.await();
         InOrder inOrder = inOrder(first, second);
 
         inOrder.verify(second, times(1)).call();
@@ -236,9 +209,10 @@ public void call() {
     }
 
     @Test
-    public final void testMixOfDelayedAndNonDelayedActions() {
-        final CurrentThreadScheduler scheduler = new CurrentThreadScheduler();
+    public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
 
+        final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
         final Action0 second = mock(Action0.class);
         final Action0 third = mock(Action0.class);
@@ -251,16 +225,94 @@ public void call() {
                 scheduler.schedule(second, 300, TimeUnit.MILLISECONDS);
                 scheduler.schedule(third, 100, TimeUnit.MILLISECONDS);
                 scheduler.schedule(fourth);
+                scheduler.schedule(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+                }, 400, TimeUnit.MILLISECONDS);
             }
         });
 
+        latch.await();
         InOrder inOrder = inOrder(first, second, third, fourth);
 
         inOrder.verify(first, times(1)).call();
         inOrder.verify(fourth, times(1)).call();
         inOrder.verify(third, times(1)).call();
         inOrder.verify(second, times(1)).call();
+    }
+
+    @Test
+    public final void testRecursiveExecutionWithAction0() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+        final AtomicInteger i = new AtomicInteger();
+        final CountDownLatch latch = new CountDownLatch(1);
+        scheduler.schedule(new Action1() {
+
+            @Override
+            public void call(Action0 self) {
+                if (i.incrementAndGet() < 100) {
+                    self.call();
+                } else {
+                    latch.countDown();
+                }
+            }
+        });
+
+        latch.await();
+        assertEquals(100, i.get());
+    }
+
+    @Test
+    public final void testRecursiveExecutionWithFunc2() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+        final AtomicInteger i = new AtomicInteger();
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        scheduler.schedule(0, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Integer state) {
+                i.set(state);
+                if (state < 100) {
+                    return innerScheduler.schedule(state + 1, this);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+
+        });
+
+        latch.await();
+        assertEquals(100, i.get());
+    }
+
+    @Test
+    public final void testRecursiveExecutionWithFunc2AndDelayTime() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+        final AtomicInteger i = new AtomicInteger();
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        scheduler.schedule(0, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler innerScheduler, Integer state) {
+                i.set(state);
+                if (state < 100) {
+                    return innerScheduler.schedule(state + 1, this, 5, TimeUnit.MILLISECONDS);
+                } else {
+                    latch.countDown();
+                    return Subscriptions.empty();
+                }
+            }
+
+        }, 50, TimeUnit.MILLISECONDS);
 
+        latch.await();
+        assertEquals(100, i.get());
     }
 
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index ff3e6c138b..a00878de10 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -15,6 +15,8 @@
  */
 package rx.schedulers;
 
+import org.junit.Test;
+
 import rx.Scheduler;
 
 public class ImmediateSchedulerTest extends AbstractSchedulerTests {
@@ -24,4 +26,25 @@ protected Scheduler getScheduler() {
         return ImmediateScheduler.getInstance();
     }
 
+    @Override
+    @Test
+    public final void testNestedActions() {
+        // ordering of nested actions will not match other schedulers
+        // because there is no reordering or concurrency with ImmediateScheduler
+    }
+
+    @Override
+    @Test
+    public final void testSequenceOfDelayedActions() {
+        // ordering of nested actions will not match other schedulers
+        // because there is no reordering or concurrency with ImmediateScheduler
+    }
+
+    @Override
+    @Test
+    public final void testMixOfDelayedAndNonDelayedActions() {
+        // ordering of nested actions will not match other schedulers
+        // because there is no reordering or concurrency with ImmediateScheduler
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
index 294193b167..80c36e9bd3 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -20,8 +20,8 @@ public static void main(String args[]) {
         usingFunc2(Schedulers.newThread());
         usingAction0(Schedulers.newThread());
 
-//        usingFunc2(Schedulers.currentThread());
-//        usingAction0(Schedulers.currentThread());
+        usingFunc2(Schedulers.currentThread());
+        usingAction0(Schedulers.currentThread());
 
         usingFunc2(Schedulers.threadPoolForComputation());
         usingAction0(Schedulers.threadPoolForComputation());

From 28dd5fcdb393c7dcaea76138f6e9c8fece893c49 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 31 Dec 2013 10:10:20 -0800
Subject: [PATCH 168/441] Small ObserveOn Improvements
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- use Long instead of Int so we don’t overflow
- migrate from deprecated method
---
 .../src/main/java/rx/operators/OperationObserveOn.java       | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
index 2f569ea75f..b655d2c53e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
@@ -17,6 +17,7 @@
 
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Notification;
 import rx.Observable;
@@ -71,7 +72,7 @@ private class Observation {
             final CompositeSubscription compositeSubscription = new CompositeSubscription();
             final MultipleAssignmentSubscription recursiveSubscription = new MultipleAssignmentSubscription();
             final ConcurrentLinkedQueue> queue = new ConcurrentLinkedQueue>();
-            final AtomicInteger counter = new AtomicInteger(0);
+            final AtomicLong counter = new AtomicLong(0);
             private volatile Scheduler recursiveScheduler;
 
             public Observation(Observer observer) {
@@ -108,7 +109,7 @@ public Subscription call(Scheduler innerScheduler, T state) {
                 }
 
                 void processQueue() {
-                    recursiveSubscription.setSubscription(recursiveScheduler.schedule(new Action1() {
+                    recursiveSubscription.set(recursiveScheduler.schedule(new Action1() {
                         @Override
                         public void call(Action0 self) {
                             Notification not = queue.poll();

From 43e3d777bb03c020eb5f9ad2aa32c4ae75111271 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 31 Dec 2013 10:37:41 -0800
Subject: [PATCH 169/441] CurrentThreadScheduler Fixes

- outer/inner scheduling so nested order is correct while not deadlocking on certain nested use cases as found in previous testing
---
 .../rx/schedulers/CurrentThreadScheduler.java | 76 +++++++++++++------
 1 file changed, 52 insertions(+), 24 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
index 67d66aa4aa..7d64c301cc 100644
--- a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
@@ -21,8 +21,8 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.MultipleAssignmentSubscription;
+import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 /**
@@ -36,7 +36,17 @@ public static CurrentThreadScheduler getInstance() {
         return INSTANCE;
     }
 
-    private static final ThreadLocal> QUEUE = new ThreadLocal>();
+    private static final ThreadLocal> QUEUE = new ThreadLocal>() {
+        protected java.util.PriorityQueue initialValue() {
+            return new PriorityQueue();
+        };
+    };
+
+    private static final ThreadLocal PROCESSING = new ThreadLocal() {
+        protected Boolean initialValue() {
+            return Boolean.FALSE;
+        };
+    };
 
     /* package accessible for unit tests */CurrentThreadScheduler() {
     }
@@ -45,8 +55,8 @@ public static CurrentThreadScheduler getInstance() {
     public  Subscription schedule(T state, Func2 action) {
         // immediately move to the InnerCurrentThreadScheduler
         InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
-        DiscardableAction discardableAction = new DiscardableAction(state, action);
-        enqueue(innerScheduler, discardableAction, now());
+        innerScheduler.enqueue(new DiscardableAction(state, action), now());
+        enqueueFromOuter(innerScheduler, now());
         return innerScheduler;
     }
 
@@ -54,41 +64,48 @@ public  Subscription schedule(T state, Func2 Subscription schedule(T state, Func2 action, long dueTime, TimeUnit unit) {
         long execTime = now() + unit.toMillis(dueTime);
 
-        // immediately move to the InnerCurrentThreadScheduler
+        // create an inner scheduler and queue it for execution
         InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
-        DiscardableAction discardableAction = new DiscardableAction(state, new SleepingAction(action, this, execTime));
-        enqueue(innerScheduler, discardableAction, execTime);
-        return discardableAction;
+        innerScheduler.enqueue(new DiscardableAction(state, new SleepingAction(action, this, execTime)), execTime);
+        enqueueFromOuter(innerScheduler, execTime);
+        return innerScheduler;
     }
 
-    private static void enqueue(Scheduler scheduler, DiscardableAction action, long execTime) {
+    /*
+     * This will accept InnerCurrentThreadScheduler instances and execute them in order they are received
+     * and on each of them will loop internally until each is complete.
+     */
+    private void enqueueFromOuter(final InnerCurrentThreadScheduler innerScheduler, long execTime) {
+        // Note that everything here is single-threaded so we won't have race conditions
         PriorityQueue queue = QUEUE.get();
-        boolean exec = queue == null;
+        queue.add(new TimedAction(new Func1() {
 
-        if (exec) {
-            queue = new PriorityQueue();
-            QUEUE.set(queue);
-        }
-
-        queue.add(new TimedAction(action, execTime, counter.incrementAndGet()));
+            @Override
+            public Subscription call(Scheduler _) {
+                // when the InnerCurrentThreadScheduler gets scheduled we want to process its tasks
+                return innerScheduler.startProcessing();
+            }
+        }, execTime, counter.incrementAndGet()));
 
-        if (exec) {
+        // first time through starts the loop
+        if (!PROCESSING.get()) {
+            PROCESSING.set(Boolean.TRUE);
             while (!queue.isEmpty()) {
-                queue.poll().action.call(scheduler);
+                queue.poll().action.call(innerScheduler);
             }
-
-            QUEUE.set(null);
+            PROCESSING.set(Boolean.FALSE);
         }
     }
 
     private static class InnerCurrentThreadScheduler extends Scheduler implements Subscription {
         private final MultipleAssignmentSubscription childSubscription = new MultipleAssignmentSubscription();
+        private final PriorityQueue innerQueue = new PriorityQueue();
 
         @Override
         public  Subscription schedule(T state, Func2 action) {
             DiscardableAction discardableAction = new DiscardableAction(state, action);
             childSubscription.set(discardableAction);
-            enqueue(this, discardableAction, now());
+            enqueue(discardableAction, now());
             return childSubscription;
         }
 
@@ -98,10 +115,21 @@ public  Subscription schedule(T state, Func2 discardableAction = new DiscardableAction(state, action);
             childSubscription.set(discardableAction);
-            enqueue(this, discardableAction, execTime);
+            enqueue(discardableAction, execTime);
             return childSubscription;
         }
 
+        private void enqueue(Func1 action, long execTime) {
+            innerQueue.add(new TimedAction(action, execTime, counter.incrementAndGet()));
+        }
+
+        private Subscription startProcessing() {
+            while (!innerQueue.isEmpty()) {
+                innerQueue.poll().action.call(this);
+            }
+            return this;
+        }
+
         @Override
         public void unsubscribe() {
             childSubscription.unsubscribe();
@@ -113,11 +141,11 @@ public void unsubscribe() {
      * Use time to sort items so delayed actions are sorted to their appropriate position in the queue.
      */
     private static class TimedAction implements Comparable {
-        final DiscardableAction action;
+        final Func1 action;
         final Long execTime;
         final Long count; // In case if time between enqueueing took less than 1ms
 
-        private TimedAction(DiscardableAction action, Long execTime, Long count) {
+        private TimedAction(Func1 action, Long execTime, Long count) {
             this.action = action;
             this.execTime = execTime;
             this.count = count;

From 2c3db738bc854ca99167859091ef0482e35a8012 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 31 Dec 2013 10:51:59 -0800
Subject: [PATCH 170/441] Fix CurrentThreadScheduler Delay Bug

- introduced a bug during refactor, caught it while updating unit tests
---
 .../java/rx/schedulers/CurrentThreadScheduler.java     | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
index 7d64c301cc..f570e38f55 100644
--- a/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/CurrentThreadScheduler.java
@@ -55,18 +55,18 @@ protected Boolean initialValue() {
     public  Subscription schedule(T state, Func2 action) {
         // immediately move to the InnerCurrentThreadScheduler
         InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
-        innerScheduler.enqueue(new DiscardableAction(state, action), now());
+        innerScheduler.schedule(state, action);
         enqueueFromOuter(innerScheduler, now());
         return innerScheduler;
     }
 
     @Override
-    public  Subscription schedule(T state, Func2 action, long dueTime, TimeUnit unit) {
-        long execTime = now() + unit.toMillis(dueTime);
+    public  Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) {
+        long execTime = now() + unit.toMillis(delayTime);
 
         // create an inner scheduler and queue it for execution
         InnerCurrentThreadScheduler innerScheduler = new InnerCurrentThreadScheduler();
-        innerScheduler.enqueue(new DiscardableAction(state, new SleepingAction(action, this, execTime)), execTime);
+        innerScheduler.schedule(state, action, delayTime, unit);
         enqueueFromOuter(innerScheduler, execTime);
         return innerScheduler;
     }
@@ -113,7 +113,7 @@ public  Subscription schedule(T state, Func2 Subscription schedule(T state, Func2 action, long delayTime, TimeUnit unit) {
             long execTime = now() + unit.toMillis(delayTime);
 
-            DiscardableAction discardableAction = new DiscardableAction(state, action);
+            DiscardableAction discardableAction = new DiscardableAction(state, new SleepingAction(action, this, execTime));
             childSubscription.set(discardableAction);
             enqueue(discardableAction, execTime);
             return childSubscription;

From 1f7d6dccdf953a7d5ec68e847cdf5c2f399107b8 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 31 Dec 2013 11:00:30 -0800
Subject: [PATCH 171/441] Updated Schedulers Unit Tests

- merged all scheduler tests into the same package
- using inheritance so that the same tests are applied to each of the different Scheduler implementations
- manual test (too slow for normal execution) can be run to test memory leaks (TestRecursionMemoryUsage.java)
---
 .../src/test/java/rx/SchedulersTest.java      | 582 ------------------
 .../AbstractSchedulerConcurrencyTests.java    | 134 ++++
 .../rx/schedulers/AbstractSchedulerTests.java | 281 ++++++++-
 .../CurrentThreadSchedulerTest.java           |  31 +
 .../rx/schedulers/ExecutorSchedulerTests.java |  75 +++
 .../rx/schedulers/ImmediateSchedulerTest.java |  54 ++
 .../rx/schedulers/NewThreadSchedulerTest.java |   2 +-
 .../schedulers/TestRecursionMemoryUsage.java  |  15 +
 .../java/rx/schedulers/TestSchedulerTest.java |  96 +++
 9 files changed, 680 insertions(+), 590 deletions(-)
 delete mode 100644 rxjava-core/src/test/java/rx/SchedulersTest.java
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java

diff --git a/rxjava-core/src/test/java/rx/SchedulersTest.java b/rxjava-core/src/test/java/rx/SchedulersTest.java
deleted file mode 100644
index 62e74f5798..0000000000
--- a/rxjava-core/src/test/java/rx/SchedulersTest.java
+++ /dev/null
@@ -1,582 +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 org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-
-import java.util.Date;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mockito;
-
-import rx.Observable.OnSubscribeFunc;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
-import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
-
-public class SchedulersTest {
-
-    @SuppressWarnings("unchecked")
-    // mocking is unchecked, unfortunately
-    @Test
-    public void testPeriodicScheduling() {
-        final Func1 calledOp = mock(Func1.class);
-
-        final TestScheduler scheduler = new TestScheduler();
-        Subscription subscription = scheduler.schedulePeriodically(new Action0() {
-            @Override
-            public void call() {
-                System.out.println(scheduler.now());
-                calledOp.call(scheduler.now());
-            }
-        }, 1, 2, TimeUnit.SECONDS);
-
-        verify(calledOp, never()).call(anyLong());
-
-        InOrder inOrder = Mockito.inOrder(calledOp);
-
-        scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
-        inOrder.verify(calledOp, never()).call(anyLong());
-
-        scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
-        inOrder.verify(calledOp, times(1)).call(1000L);
-
-        scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
-        inOrder.verify(calledOp, never()).call(3000L);
-
-        scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
-        inOrder.verify(calledOp, times(1)).call(3000L);
-
-        scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
-        inOrder.verify(calledOp, times(1)).call(5000L);
-        inOrder.verify(calledOp, times(1)).call(7000L);
-
-        subscription.unsubscribe();
-        scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
-        inOrder.verify(calledOp, never()).call(anyLong());
-    }
-
-    @Test
-    public void testComputationThreadPool1() {
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.subscribeOn(Schedulers.threadPoolForComputation()).toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testIOThreadPool1() {
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().startsWith("RxIOThreadPool"));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.subscribeOn(Schedulers.threadPoolForIO()).toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testMergeWithoutScheduler1() {
-
-        final String currentThreadName = Thread.currentThread().getName();
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testMergeWithImmediateScheduler1() {
-
-        final String currentThreadName = Thread.currentThread().getName();
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.immediate()).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testMergeWithCurrentThreadScheduler1() {
-
-        final String currentThreadName = Thread.currentThread().getName();
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.currentThread()).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testMergeWithScheduler1() {
-
-        final String currentThreadName = Thread.currentThread().getName();
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-        Observable o2 = Observable. from(6, 7, 8, 9, 10);
-        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.threadPoolForComputation()).map(new Func1() {
-
-            @Override
-            public String call(Integer t) {
-                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
-                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
-                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
-            }
-        });
-
-        o.toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
-
-    @Test
-    public void testSubscribeWithScheduler1() throws InterruptedException {
-
-        final AtomicInteger count = new AtomicInteger();
-
-        Observable o1 = Observable. from(1, 2, 3, 4, 5);
-
-        o1.subscribe(new Action1() {
-
-            @Override
-            public void call(Integer t) {
-                System.out.println("Thread: " + Thread.currentThread().getName());
-                System.out.println("t: " + t);
-                count.incrementAndGet();
-            }
-        });
-
-        // the above should be blocking so we should see a count of 5
-        assertEquals(5, count.get());
-
-        count.set(0);
-
-        // now we'll subscribe with a scheduler and it should be async
-
-        final String currentThreadName = Thread.currentThread().getName();
-
-        // latches for deterministically controlling the test below across threads
-        final CountDownLatch latch = new CountDownLatch(5);
-        final CountDownLatch first = new CountDownLatch(1);
-
-        o1.subscribe(new Action1() {
-
-            @Override
-            public void call(Integer t) {
-                try {
-                    // we block the first one so we can assert this executes asynchronously with a count
-                    first.await(1000, TimeUnit.SECONDS);
-                } catch (InterruptedException e) {
-                    throw new RuntimeException("The latch should have released if we are async.", e);
-                }
-                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
-                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
-                System.out.println("Thread: " + Thread.currentThread().getName());
-                System.out.println("t: " + t);
-                count.incrementAndGet();
-                latch.countDown();
-            }
-        }, Schedulers.threadPoolForComputation());
-
-        // assert we are async
-        assertEquals(0, count.get());
-        // release the latch so it can go forward
-        first.countDown();
-
-        // wait for all 5 responses
-        latch.await();
-        assertEquals(5, count.get());
-    }
-
-    @Test
-    public void testRecursiveScheduler1() {
-        Observable obs = Observable.create(new OnSubscribeFunc() {
-            @Override
-            public Subscription onSubscribe(final Observer observer) {
-                return Schedulers.currentThread().schedule(0, new Func2() {
-                    @Override
-                    public Subscription call(Scheduler scheduler, Integer i) {
-                        if (i > 42) {
-                            observer.onCompleted();
-                            return Subscriptions.empty();
-                        }
-
-                        observer.onNext(i);
-
-                        return scheduler.schedule(i + 1, this);
-                    }
-                });
-            }
-        });
-
-        final AtomicInteger lastValue = new AtomicInteger();
-        obs.toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(Integer v) {
-                System.out.println("Value: " + v);
-                lastValue.set(v);
-            }
-        });
-
-        assertEquals(42, lastValue.get());
-    }
-
-    @Test
-    public void testRecursiveScheduler2() throws InterruptedException {
-        // use latches instead of Thread.sleep
-        final CountDownLatch latch = new CountDownLatch(10);
-        final CountDownLatch completionLatch = new CountDownLatch(1);
-
-        Observable obs = Observable.create(new OnSubscribeFunc() {
-            @Override
-            public Subscription onSubscribe(final Observer observer) {
-
-                return Schedulers.threadPoolForComputation().schedule(new BooleanSubscription(), new Func2() {
-                    @Override
-                    public Subscription call(Scheduler scheduler, BooleanSubscription cancel) {
-                        if (cancel.isUnsubscribed()) {
-                            observer.onCompleted();
-                            completionLatch.countDown();
-                            return Subscriptions.empty();
-                        }
-
-                        observer.onNext(42);
-                        latch.countDown();
-
-                        // this will recursively schedule this task for execution again
-                        scheduler.schedule(cancel, this);
-
-                        return cancel;
-                    }
-                });
-            }
-        });
-
-        final AtomicInteger count = new AtomicInteger();
-        final AtomicBoolean completed = new AtomicBoolean(false);
-        Subscription subscribe = obs.subscribe(new Observer() {
-            @Override
-            public void onCompleted() {
-                System.out.println("Completed");
-                completed.set(true);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                System.out.println("Error");
-            }
-
-            @Override
-            public void onNext(Integer args) {
-                count.incrementAndGet();
-                System.out.println(args);
-            }
-        });
-
-        if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
-            fail("Timed out waiting on onNext latch");
-        }
-
-        // now unsubscribe and ensure it stops the recursive loop
-        subscribe.unsubscribe();
-        System.out.println("unsubscribe");
-
-        if (!completionLatch.await(5000, TimeUnit.MILLISECONDS)) {
-            fail("Timed out waiting on completion latch");
-        }
-
-        // the count can be 10 or higher due to thread scheduling of the unsubscribe vs the scheduler looping to emit the count
-        assertTrue(count.get() >= 10);
-        assertTrue(completed.get());
-    }
-
-    @Test
-    public void testSchedulingWithDueTime() throws InterruptedException {
-
-        final CountDownLatch latch = new CountDownLatch(5);
-        final AtomicInteger counter = new AtomicInteger();
-
-        long start = System.currentTimeMillis();
-
-        Schedulers.threadPoolForComputation().schedule(null, new Func2() {
-
-            @Override
-            public Subscription call(Scheduler scheduler, String state) {
-                System.out.println("doing work");
-                counter.incrementAndGet();
-                latch.countDown();
-                if (latch.getCount() == 0) {
-                    return Subscriptions.empty();
-                } else {
-                    return scheduler.schedule(state, this, new Date(System.currentTimeMillis() + 50));
-                }
-            }
-        }, new Date(System.currentTimeMillis() + 100));
-
-        if (!latch.await(3000, TimeUnit.MILLISECONDS)) {
-            fail("didn't execute ... timed out");
-        }
-
-        long end = System.currentTimeMillis();
-
-        assertEquals(5, counter.get());
-        if ((end - start) < 250) {
-            fail("it should have taken over 250ms since each step was scheduled 50ms in the future");
-        }
-    }
-
-    @Test
-    public void testConcurrentOnNextFailsValidation() throws InterruptedException {
-
-        final int count = 10;
-        final CountDownLatch latch = new CountDownLatch(count);
-        Observable o = Observable.create(new OnSubscribeFunc() {
-
-            @Override
-            public Subscription onSubscribe(final Observer observer) {
-                for (int i = 0; i < count; i++) {
-                    final int v = i;
-                    new Thread(new Runnable() {
-
-                        @Override
-                        public void run() {
-                            observer.onNext("v: " + v);
-
-                            latch.countDown();
-                        }
-                    }).start();
-                }
-                return Subscriptions.empty();
-            }
-        });
-
-        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
-        // this should call onNext concurrently
-        o.subscribe(observer);
-
-        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
-            fail("timed out");
-        }
-
-        if (observer.error.get() == null) {
-            fail("We expected error messages due to concurrency");
-        }
-    }
-
-    @Test
-    public void testObserveOn() throws InterruptedException {
-
-        Observable o = Observable.from("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten");
-
-        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
-
-        o.observeOn(Schedulers.threadPoolForComputation()).subscribe(observer);
-
-        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
-            fail("timed out");
-        }
-
-        if (observer.error.get() != null) {
-            observer.error.get().printStackTrace();
-            fail("Error: " + observer.error.get().getMessage());
-        }
-    }
-
-    @Test
-    public void testSubscribeOnNestedConcurrency() throws InterruptedException {
-
-        Observable o = Observable.from("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")
-                .mapMany(new Func1>() {
-
-                    @Override
-                    public Observable call(final String v) {
-                        return Observable.create(new OnSubscribeFunc() {
-
-                            @Override
-                            public Subscription onSubscribe(final Observer observer) {
-                                observer.onNext("value_after_map-" + v);
-                                observer.onCompleted();
-                                return Subscriptions.empty();
-                            }
-                        }).subscribeOn(Schedulers.newThread()); // subscribe on a new thread
-                    }
-                });
-
-        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
-
-        o.subscribe(observer);
-
-        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
-            fail("timed out");
-        }
-
-        if (observer.error.get() != null) {
-            observer.error.get().printStackTrace();
-            fail("Error: " + observer.error.get().getMessage());
-        }
-    }
-
-    @Test
-    public void testRecursion() {
-        TestScheduler s = new TestScheduler();
-
-        final AtomicInteger counter = new AtomicInteger(0);
-
-        Subscription subscription = s.schedule(new Action1() {
-
-            @Override
-            public void call(Action0 self) {
-                counter.incrementAndGet();
-                System.out.println("counter: " + counter.get());
-                self.call();
-            }
-
-        });
-        subscription.unsubscribe();
-        assertEquals(0, counter.get());
-    }
-
-    /**
-     * Used to determine if onNext is being invoked concurrently.
-     * 
-     * @param 
-     */
-    private static class ConcurrentObserverValidator implements Observer {
-
-        final AtomicInteger concurrentCounter = new AtomicInteger();
-        final AtomicReference error = new AtomicReference();
-        final CountDownLatch completed = new CountDownLatch(1);
-
-        @Override
-        public void onCompleted() {
-            completed.countDown();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            completed.countDown();
-            error.set(e);
-        }
-
-        @Override
-        public void onNext(T args) {
-            int count = concurrentCounter.incrementAndGet();
-            System.out.println("ConcurrentObserverValidator.onNext: " + args);
-            if (count > 1) {
-                onError(new RuntimeException("we should not have concurrent execution of onNext"));
-            }
-            try {
-                try {
-                    // take some time so other onNext calls could pile up (I haven't yet thought of a way to do this without sleeping)
-                    Thread.sleep(50);
-                } catch (InterruptedException e) {
-                    // ignore
-                }
-            } finally {
-                concurrentCounter.decrementAndGet();
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 6602d5071d..ef78d2ee11 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -4,15 +4,18 @@
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
+import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
@@ -192,4 +195,135 @@ public void call(Action0 self) {
         latch.await();
     }
 
+    @Test
+    public void testRecursiveScheduler2() throws InterruptedException {
+        // use latches instead of Thread.sleep
+        final CountDownLatch latch = new CountDownLatch(10);
+        final CountDownLatch completionLatch = new CountDownLatch(1);
+
+        Observable obs = Observable.create(new OnSubscribeFunc() {
+            @Override
+            public Subscription onSubscribe(final Observer observer) {
+
+                return getScheduler().schedule(null, new Func2() {
+                    @Override
+                    public Subscription call(Scheduler scheduler, Void v) {
+                        observer.onNext(42);
+                        latch.countDown();
+
+                        // this will recursively schedule this task for execution again
+                        scheduler.schedule(null, this);
+
+                        return Subscriptions.create(new Action0() {
+
+                            @Override
+                            public void call() {
+                                observer.onCompleted();
+                                completionLatch.countDown();
+                            }
+
+                        });
+                    }
+                });
+            }
+        });
+
+        final AtomicInteger count = new AtomicInteger();
+        final AtomicBoolean completed = new AtomicBoolean(false);
+        Subscription subscribe = obs.subscribe(new Observer() {
+            @Override
+            public void onCompleted() {
+                System.out.println("Completed");
+                completed.set(true);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("Error");
+            }
+
+            @Override
+            public void onNext(Integer args) {
+                count.incrementAndGet();
+                System.out.println(args);
+            }
+        });
+
+        if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
+            fail("Timed out waiting on onNext latch");
+        }
+
+        // now unsubscribe and ensure it stops the recursive loop
+        subscribe.unsubscribe();
+        System.out.println("unsubscribe");
+
+        if (!completionLatch.await(5000, TimeUnit.MILLISECONDS)) {
+            fail("Timed out waiting on completion latch");
+        }
+
+        // the count can be 10 or higher due to thread scheduling of the unsubscribe vs the scheduler looping to emit the count
+        assertTrue(count.get() >= 10);
+        assertTrue(completed.get());
+    }
+
+    @Test
+    public final void testSubscribeWithScheduler() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+
+        final AtomicInteger count = new AtomicInteger();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+
+        o1.subscribe(new Action1() {
+
+            @Override
+            public void call(Integer t) {
+                System.out.println("Thread: " + Thread.currentThread().getName());
+                System.out.println("t: " + t);
+                count.incrementAndGet();
+            }
+        });
+
+        // the above should be blocking so we should see a count of 5
+        assertEquals(5, count.get());
+
+        count.set(0);
+
+        // now we'll subscribe with a scheduler and it should be async
+
+        final String currentThreadName = Thread.currentThread().getName();
+
+        // latches for deterministically controlling the test below across threads
+        final CountDownLatch latch = new CountDownLatch(5);
+        final CountDownLatch first = new CountDownLatch(1);
+
+        o1.subscribe(new Action1() {
+
+            @Override
+            public void call(Integer t) {
+                try {
+                    // we block the first one so we can assert this executes asynchronously with a count
+                    first.await(1000, TimeUnit.SECONDS);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("The latch should have released if we are async.", e);
+                }
+
+                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
+                System.out.println("Thread: " + Thread.currentThread().getName());
+                System.out.println("t: " + t);
+                count.incrementAndGet();
+                latch.countDown();
+            }
+        }, scheduler);
+
+        // assert we are async
+        assertEquals(0, count.get());
+        // release the latch so it can go forward
+        first.countDown();
+
+        // wait for all 5 responses
+        latch.await();
+        assertEquals(5, count.get());
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 508727bc12..e83f5936c7 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -1,14 +1,35 @@
+/**
+ * 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.schedulers;
 
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
 import org.mockito.InOrder;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
@@ -19,6 +40,7 @@
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 /**
@@ -141,7 +163,7 @@ public void call() {
         InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
 
         scheduler.schedule(thirdAction);
-        
+
         latch.await();
 
         inOrder.verify(thirdStepStart, times(1)).call();
@@ -152,6 +174,37 @@ public void call() {
         inOrder.verify(firstStepEnd, times(1)).call();
     }
 
+    @Test
+    public final void testNestedScheduling() {
+
+        Observable ids = Observable.from(Arrays.asList(1, 2), getScheduler());
+
+        Observable m = ids.flatMap(new Func1>() {
+
+            @Override
+            public Observable call(Integer id) {
+                return Observable.from(Arrays.asList("a-" + id, "b-" + id), getScheduler())
+                        .map(new Func1() {
+
+                            @Override
+                            public String call(String s) {
+                                return "names=>" + s;
+                            }
+                        });
+            }
+
+        });
+
+        List strings = m.toList().toBlockingObservable().last();
+
+        assertEquals(4, strings.size());
+        assertEquals("names=>a-1", strings.get(0));
+        assertEquals("names=>b-1", strings.get(1));
+        assertEquals("names=>a-2", strings.get(2));
+        assertEquals("names=>b-2", strings.get(3));
+    }
+
+    @SuppressWarnings("rawtypes")
     @Test
     public final void testSequenceOfActions() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
@@ -160,15 +213,21 @@ public final void testSequenceOfActions() throws InterruptedException {
         final Action0 first = mock(Action0.class);
         final Action0 second = mock(Action0.class);
 
-        scheduler.schedule(first);
-        scheduler.schedule(second);
-        scheduler.schedule(new Action0() {
+        // make it wait until after the second is called
+        doAnswer(new Answer() {
 
             @Override
-            public void call() {
-                latch.countDown();
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                try {
+                    return invocation.getMock();
+                } finally {
+                    latch.countDown();
+                }
             }
-        });
+        }).when(second).call();
+
+        scheduler.schedule(first);
+        scheduler.schedule(second);
 
         latch.await();
 
@@ -315,4 +374,212 @@ public Subscription call(Scheduler innerScheduler, Integer state) {
         assertEquals(100, i.get());
     }
 
+    @Test
+    public final void testRecursiveSchedulerSimple() {
+        final Scheduler scheduler = getScheduler();
+
+        Observable obs = Observable.create(new OnSubscribeFunc() {
+            @Override
+            public Subscription onSubscribe(final Observer observer) {
+                return scheduler.schedule(0, new Func2() {
+                    @Override
+                    public Subscription call(Scheduler scheduler, Integer i) {
+                        if (i > 42) {
+                            observer.onCompleted();
+                            return Subscriptions.empty();
+                        }
+
+                        observer.onNext(i);
+
+                        return scheduler.schedule(i + 1, this);
+                    }
+                });
+            }
+        });
+
+        final AtomicInteger lastValue = new AtomicInteger();
+        obs.toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(Integer v) {
+                System.out.println("Value: " + v);
+                lastValue.set(v);
+            }
+        });
+
+        assertEquals(42, lastValue.get());
+    }
+
+    @Test
+    public final void testSchedulingWithDueTime() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+
+        final CountDownLatch latch = new CountDownLatch(5);
+        final AtomicInteger counter = new AtomicInteger();
+
+        long start = System.currentTimeMillis();
+
+        scheduler.schedule(null, new Func2() {
+
+            @Override
+            public Subscription call(Scheduler scheduler, String state) {
+                System.out.println("doing work");
+                counter.incrementAndGet();
+                latch.countDown();
+                if (latch.getCount() == 0) {
+                    return Subscriptions.empty();
+                } else {
+                    return scheduler.schedule(state, this, new Date(scheduler.now() + 50));
+                }
+            }
+        }, new Date(scheduler.now() + 100));
+
+        if (!latch.await(3000, TimeUnit.MILLISECONDS)) {
+            fail("didn't execute ... timed out");
+        }
+
+        long end = System.currentTimeMillis();
+
+        assertEquals(5, counter.get());
+        System.out.println("Time taken: " + (end - start));
+        if ((end - start) < 250) {
+            fail("it should have taken over 250ms since each step was scheduled 50ms in the future");
+        }
+    }
+
+    @Test
+    public final void testConcurrentOnNextFailsValidation() throws InterruptedException {
+        final int count = 10;
+        final CountDownLatch latch = new CountDownLatch(count);
+        Observable o = Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer observer) {
+                for (int i = 0; i < count; i++) {
+                    final int v = i;
+                    new Thread(new Runnable() {
+
+                        @Override
+                        public void run() {
+                            observer.onNext("v: " + v);
+
+                            latch.countDown();
+                        }
+                    }).start();
+                }
+                return Subscriptions.empty();
+            }
+        });
+
+        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
+        // this should call onNext concurrently
+        o.subscribe(observer);
+
+        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
+            fail("timed out");
+        }
+
+        if (observer.error.get() == null) {
+            fail("We expected error messages due to concurrency");
+        }
+    }
+
+    @Test
+    public final void testObserveOn() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+
+        Observable o = Observable.from("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten");
+
+        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
+
+        o.observeOn(scheduler).subscribe(observer);
+
+        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
+            fail("timed out");
+        }
+
+        if (observer.error.get() != null) {
+            observer.error.get().printStackTrace();
+            fail("Error: " + observer.error.get().getMessage());
+        }
+    }
+
+    @Test
+    public final void testSubscribeOnNestedConcurrency() throws InterruptedException {
+        final Scheduler scheduler = getScheduler();
+
+        Observable o = Observable.from("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")
+                .mergeMap(new Func1>() {
+
+                    @Override
+                    public Observable call(final String v) {
+                        return Observable.create(new OnSubscribeFunc() {
+
+                            @Override
+                            public Subscription onSubscribe(final Observer observer) {
+                                observer.onNext("value_after_map-" + v);
+                                observer.onCompleted();
+                                return Subscriptions.empty();
+                            }
+                        }).subscribeOn(scheduler);
+                    }
+                });
+
+        ConcurrentObserverValidator observer = new ConcurrentObserverValidator();
+
+        o.subscribe(observer);
+
+        if (!observer.completed.await(3000, TimeUnit.MILLISECONDS)) {
+            fail("timed out");
+        }
+
+        if (observer.error.get() != null) {
+            observer.error.get().printStackTrace();
+            fail("Error: " + observer.error.get().getMessage());
+        }
+    }
+
+    /**
+     * Used to determine if onNext is being invoked concurrently.
+     * 
+     * @param 
+     */
+    private static class ConcurrentObserverValidator implements Observer {
+
+        final AtomicInteger concurrentCounter = new AtomicInteger();
+        final AtomicReference error = new AtomicReference();
+        final CountDownLatch completed = new CountDownLatch(1);
+
+        @Override
+        public void onCompleted() {
+            completed.countDown();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            completed.countDown();
+            error.set(e);
+        }
+
+        @Override
+        public void onNext(T args) {
+            int count = concurrentCounter.incrementAndGet();
+            System.out.println("ConcurrentObserverValidator.onNext: " + args);
+            if (count > 1) {
+                onError(new RuntimeException("we should not have concurrent execution of onNext"));
+            }
+            try {
+                try {
+                    // take some time so other onNext calls could pile up (I haven't yet thought of a way to do this without sleeping)
+                    Thread.sleep(50);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            } finally {
+                concurrentCounter.decrementAndGet();
+            }
+        }
+
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
index 961617bbd8..59fb2fe46c 100644
--- a/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/CurrentThreadSchedulerTest.java
@@ -15,7 +15,14 @@
  */
 package rx.schedulers;
 
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import rx.Observable;
 import rx.Scheduler;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 
 public class CurrentThreadSchedulerTest extends AbstractSchedulerTests {
 
@@ -24,4 +31,28 @@ protected Scheduler getScheduler() {
         return CurrentThreadScheduler.getInstance();
     }
 
+    @Test
+    public final void testMergeWithCurrentThreadScheduler1() {
+
+        final String currentThreadName = Thread.currentThread().getName();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.currentThread()).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index d065475232..c44e4ceb16 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -22,10 +22,12 @@
 
 import org.junit.Test;
 
+import rx.Observable;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 public class ExecutorSchedulerTests extends AbstractSchedulerConcurrencyTests {
@@ -89,4 +91,77 @@ public void call(Action0 self) {
         assertEquals(NUM, statefulMap.get("b").intValue());
         assertEquals(NUM, statefulMap.get("nonThreadSafeCounter").intValue());
     }
+
+    @Test
+    public final void testComputationThreadPool1() {
+        final Scheduler scheduler = getScheduler();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.subscribeOn(Schedulers.threadPoolForComputation()).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
+
+    @Test
+    public final void testIOThreadPool1() {
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().startsWith("RxIOThreadPool"));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.subscribeOn(Schedulers.threadPoolForIO()).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
+
+    @Test
+    public final void testMergeWithExecutorScheduler() {
+
+        final String currentThreadName = Thread.currentThread().getName();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.threadPoolForComputation()).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertFalse(Thread.currentThread().getName().equals(currentThreadName));
+                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index a00878de10..34efd5c21d 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -15,9 +15,14 @@
  */
 package rx.schedulers;
 
+import static org.junit.Assert.*;
+
 import org.junit.Test;
 
+import rx.Observable;
 import rx.Scheduler;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 
 public class ImmediateSchedulerTest extends AbstractSchedulerTests {
 
@@ -47,4 +52,53 @@ public final void testMixOfDelayedAndNonDelayedActions() {
         // because there is no reordering or concurrency with ImmediateScheduler
     }
 
+    @Test
+    public final void testMergeWithoutScheduler() {
+
+        final String currentThreadName = Thread.currentThread().getName();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
+
+    @Test
+    public final void testMergeWithImmediateScheduler1() {
+
+        final String currentThreadName = Thread.currentThread().getName();
+
+        Observable o1 = Observable. from(1, 2, 3, 4, 5);
+        Observable o2 = Observable. from(6, 7, 8, 9, 10);
+        Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.immediate()).map(new Func1() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().equals(currentThreadName));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index eaf5855e6c..1b82db95ca 100644
--- a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -24,5 +24,5 @@ public class NewThreadSchedulerTest extends AbstractSchedulerConcurrencyTests {
     protected Scheduler getScheduler() {
         return NewThreadScheduler.getInstance();
     }
-    
+
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
index 80c36e9bd3..e2a62a76e8 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -1,3 +1,18 @@
+/**
+ * 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.schedulers;
 
 import rx.Observable;
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
new file mode 100644
index 0000000000..1d13995bef
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -0,0 +1,96 @@
+/**
+ * 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.schedulers;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+
+import rx.Subscription;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public class TestSchedulerTest {
+
+    @SuppressWarnings("unchecked")
+    // mocking is unchecked, unfortunately
+    @Test
+    public final void testPeriodicScheduling() {
+        final Func1 calledOp = mock(Func1.class);
+
+        final TestScheduler scheduler = new TestScheduler();
+        Subscription subscription = scheduler.schedulePeriodically(new Action0() {
+            @Override
+            public void call() {
+                System.out.println(scheduler.now());
+                calledOp.call(scheduler.now());
+            }
+        }, 1, 2, TimeUnit.SECONDS);
+
+        verify(calledOp, never()).call(anyLong());
+
+        InOrder inOrder = Mockito.inOrder(calledOp);
+
+        scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
+        inOrder.verify(calledOp, never()).call(anyLong());
+
+        scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
+        inOrder.verify(calledOp, times(1)).call(1000L);
+
+        scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
+        inOrder.verify(calledOp, never()).call(3000L);
+
+        scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
+        inOrder.verify(calledOp, times(1)).call(3000L);
+
+        scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
+        inOrder.verify(calledOp, times(1)).call(5000L);
+        inOrder.verify(calledOp, times(1)).call(7000L);
+
+        subscription.unsubscribe();
+        scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
+        inOrder.verify(calledOp, never()).call(anyLong());
+    }
+
+    @Test
+    public final void testRecursion() {
+        TestScheduler s = new TestScheduler();
+
+        final AtomicInteger counter = new AtomicInteger(0);
+
+        Subscription subscription = s.schedule(new Action1() {
+
+            @Override
+            public void call(Action0 self) {
+                counter.incrementAndGet();
+                System.out.println("counter: " + counter.get());
+                self.call();
+            }
+
+        });
+        subscription.unsubscribe();
+        assertEquals(0, counter.get());
+    }
+
+}

From b7e6410fe9be1cb4e3d1257a13e91506e2af9f1a Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 31 Dec 2013 14:50:49 -0800
Subject: [PATCH 172/441] Missing Header

---
 .../AbstractSchedulerConcurrencyTests.java       | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index ef78d2ee11..11dc5c1859 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -1,3 +1,18 @@
+/**
+ * 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.schedulers;
 
 import static org.junit.Assert.*;
@@ -15,7 +30,6 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
-import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;

From abe9c98b521f1fd14c6fe2e2ca42d6bca63ac256 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 1 Jan 2014 20:38:58 -0800
Subject: [PATCH 173/441] Increasing Unit Test Timeout for Slow Machines

- Increasing timeout by a lot to handle slow machines such as this: https://netflixoss.ci.cloudbees.com/job/RxJava-pull-requests/629/testReport/junit/rx.schedulers/ExecutorSchedulerTests/recursionUsingFunc2/
- The timeout is only there if a deadlock or memory leak occurs (which is what this PR is fixing) so when everything is healthy it does not timeout
---
 .../java/rx/schedulers/AbstractSchedulerConcurrencyTests.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 11dc5c1859..79b455b6ed 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -163,7 +163,7 @@ public Subscription call(Scheduler innerScheduler, Long i) {
         assertEquals(10, counter.get());
     }
 
-    @Test(timeout = 8000)
+    @Test(timeout = 20000)
     public void recursionUsingFunc2() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         getScheduler().schedule(1L, new Func2() {
@@ -185,7 +185,7 @@ public Subscription call(Scheduler innerScheduler, Long i) {
         latch.await();
     }
 
-    @Test(timeout = 8000)
+    @Test(timeout = 20000)
     public void recursionUsingAction0() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         getScheduler().schedule(new Action1() {

From 9b3a838c02b433ed8fbed014a5565fcb5b800891 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 1 Jan 2014 20:53:16 -0800
Subject: [PATCH 174/441] Remove Timeout on Tests

---
 .../java/rx/schedulers/AbstractSchedulerConcurrencyTests.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 79b455b6ed..89c3d7221f 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -163,7 +163,7 @@ public Subscription call(Scheduler innerScheduler, Long i) {
         assertEquals(10, counter.get());
     }
 
-    @Test(timeout = 20000)
+    @Test
     public void recursionUsingFunc2() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         getScheduler().schedule(1L, new Func2() {
@@ -185,7 +185,7 @@ public Subscription call(Scheduler innerScheduler, Long i) {
         latch.await();
     }
 
-    @Test(timeout = 20000)
+    @Test
     public void recursionUsingAction0() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         getScheduler().schedule(new Action1() {

From 1d0d90c0e595490b0944a7eaf11e6e317c998267 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 1 Jan 2014 20:55:43 -0800
Subject: [PATCH 175/441] Remove Validation of Ordering

- this test does a flatMap which uses merge which has non-deterministic ordering since the Observable.from can be on a new thread each time
---
 .../test/java/rx/schedulers/AbstractSchedulerTests.java  | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index e83f5936c7..ddf4f959a6 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -198,10 +198,11 @@ public String call(String s) {
         List strings = m.toList().toBlockingObservable().last();
 
         assertEquals(4, strings.size());
-        assertEquals("names=>a-1", strings.get(0));
-        assertEquals("names=>b-1", strings.get(1));
-        assertEquals("names=>a-2", strings.get(2));
-        assertEquals("names=>b-2", strings.get(3));
+        // because flatMap does a merge there is no guarantee of order
+        assertTrue(strings.contains("names=>a-1"));
+        assertTrue(strings.contains("names=>a-2"));
+        assertTrue(strings.contains("names=>b-1"));
+        assertTrue(strings.contains("names=>b-2"));
     }
 
     @SuppressWarnings("rawtypes")

From f5314b1b53e6ecb7cf78acd2106fc2ed69a6b102 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 2 Jan 2014 14:38:08 -0800
Subject: [PATCH 176/441] rxjava-computation-expressions

The conditional operators are going in this contrib module.

See https://github.com/Netflix/RxJava/issues/683
---
 .../build.gradle                              |  20 ++
 .../src/main/java/rx/Statement.java           | 191 +++++++++++++++
 .../rx/operators/OperationConditionals.java   | 107 +++++---
 .../operators/OperationConditionalsTest.java  | 230 ++++++++++--------
 rxjava-core/src/main/java/rx/Observable.java  | 160 ------------
 settings.gradle                               |   3 +-
 6 files changed, 418 insertions(+), 293 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-computation-expressions/build.gradle
 create mode 100644 rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
 rename {rxjava-core => rxjava-contrib/rxjava-computation-expressions}/src/main/java/rx/operators/OperationConditionals.java (78%)
 rename {rxjava-core => rxjava-contrib/rxjava-computation-expressions}/src/test/java/rx/operators/OperationConditionalsTest.java (82%)

diff --git a/rxjava-contrib/rxjava-computation-expressions/build.gradle b/rxjava-contrib/rxjava-computation-expressions/build.gradle
new file mode 100644
index 0000000000..21bc395344
--- /dev/null
+++ b/rxjava-contrib/rxjava-computation-expressions/build.gradle
@@ -0,0 +1,20 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    testCompile project(":rxjava-core").sourceSets.test.output 
+    provided 'junit:junit-dep:4.10'
+    provided 'org.mockito:mockito-core:1.8.5'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-computation-expressions'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+    }
+}
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
new file mode 100644
index 0000000000..7ed5201327
--- /dev/null
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
@@ -0,0 +1,191 @@
+package rx;
+
+import java.util.Map;
+
+import rx.operators.OperationConditionals;
+import rx.util.functions.Func0;
+
+/**
+ * Imperative statements expressed as Observable operators.
+ */
+public class Statement {
+
+    /**
+     * Return a particular one of several possible Observables based on a case
+     * selector.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the case key type
+     * @param 
+     *            the result value type
+     * @param caseSelector
+     *            the function that produces a case key when an
+     *            Observer subscribes
+     * @param mapOfCases
+     *            a map that maps a case key to an Observable
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or an empty Observable if no Observable matches the
+     *         key
+     */
+    public static  Observable switchCase(Func0 caseSelector,
+            Map> mapOfCases) {
+        return switchCase(caseSelector, mapOfCases, Observable. empty());
+    }
+
+    /**
+     * Return a particular one of several possible Observables based on a case
+     * selector and run it on the designated scheduler.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the case key type
+     * @param 
+     *            the result value type
+     * @param caseSelector
+     *            the function that produces a case key when an
+     *            Observer subscribes
+     * @param mapOfCases
+     *            a map that maps a case key to an Observable
+     * @param scheduler
+     *            the scheduler where the empty observable is observed
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or an empty Observable if no Observable matches the
+     *         key, but one that runs on the designated scheduler in either case
+     */
+    public static  Observable switchCase(Func0 caseSelector,
+            Map> mapOfCases, Scheduler scheduler) {
+        return switchCase(caseSelector, mapOfCases, Observable. empty(scheduler));
+    }
+
+    /**
+     * Return a particular one of several possible Observables based on a case
+     * selector, or a default Observable if the case selector does not map to
+     * a particular one.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the case key type
+     * @param 
+     *            the result value type
+     * @param caseSelector
+     *            the function that produces a case key when an
+     *            Observer subscribes
+     * @param mapOfCases
+     *            a map that maps a case key to an Observable
+     * @param defaultCase
+     *            the default Observable if the {@code mapOfCases} doesn't contain a value for the key returned by the {@case caseSelector}
+     * @return a particular Observable chosen by key from the map of
+     *         Observables, or the default case if no Observable matches the key
+     */
+    public static  Observable switchCase(Func0 caseSelector,
+            Map> mapOfCases,
+            Observable defaultCase) {
+        return Observable.create(OperationConditionals.switchCase(caseSelector, mapOfCases, defaultCase));
+    }
+
+    /**
+     * Return an Observable that replays the emissions from the source
+     * Observable, and then continues to replay them so long as a condtion is
+     * true.
+     * 
    
+     * 
+     * 
+     * @param postCondition
+     *            the post condition to test after the source
+     *            Observable completes
+     * @return an Observable that replays the emissions from the source
+     *         Observable, and then continues to replay them so long as the post
+     *         condition is true
+     */
+    public static  Observable doWhile(Observable source, Func0 postCondition) {
+        return Observable.create(OperationConditionals.doWhile(source, postCondition));
+    }
+
+    /**
+     * Return an Observable that replays the emissions from the source
+     * Observable so long as a condtion is true.
+     * 
    
+     * 
+     * 
+     * @param preCondition
+     *            the condition to evaluate before subscribing to or
+     *            replaying the source Observable
+     * @return an Observable that replays the emissions from the source
+     *         Observable so long as preCondition is true
+     */
+    public static  Observable whileDo(Observable source, Func0 preCondition) {
+        return Observable.create(OperationConditionals.whileDo(source, preCondition));
+    }
+
+    /**
+     * Return an Observable that emits the emissions from a specified Observable
+     * if a condition evaluates to true, otherwise return an empty Observable.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the result value type
+     * @param condition
+     *            the condition that decides whether to emit the emissions
+     *            from the then Observable
+     * @param then
+     *            the Observable sequence to emit to if {@code condition} is {@code true}
+     * @return an Observable that mimics the {@code then} Observable if the {@code condition} function evaluates to true, or an empty
+     *         Observable otherwise
+     */
+    public static  Observable ifThen(Func0 condition, Observable then) {
+        return ifThen(condition, then, Observable. empty());
+    }
+
+    /**
+     * Return an Observable that emits the emissions from a specified Observable
+     * if a condition evaluates to true, otherwise return an empty Observable
+     * that runs on a specified Scheduler.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the result value type
+     * @param condition
+     *            the condition that decides whether to emit the emissions
+     *            from the then Observable
+     * @param then
+     *            the Observable sequence to emit to if {@code condition} is {@code true}
+     * @param scheduler
+     *            the Scheduler on which the empty Observable runs if the
+     *            in case the condition returns false
+     * @return an Observable that mimics the {@code then} Observable if the {@code condition} function evaluates to true, or an empty
+     *         Observable running on the specified Scheduler otherwise
+     */
+    public static  Observable ifThen(Func0 condition, Observable then, Scheduler scheduler) {
+        return ifThen(condition, then, Observable. empty(scheduler));
+    }
+
+    /**
+     * Return an Observable that emits the emissions from one specified
+     * Observable if a condition evaluates to true, or from another specified
+     * Observable otherwise.
+     * 
    
+     * 
+     * 
+     * @param 
+     *            the result value type
+     * @param condition
+     *            the condition that decides which Observable to emit the
+     *            emissions from
+     * @param then
+     *            the Observable sequence to emit to if {@code condition} is {@code true}
+     * @param orElse
+     *            the Observable sequence to emit to if {@code condition} is {@code false}
+     * @return an Observable that mimics either the {@code then} or {@code orElse} Observables depending on a condition function
+     */
+    public static  Observable ifThen(Func0 condition, Observable then,
+            Observable orElse) {
+        return Observable.create(OperationConditionals.ifThen(condition, then, orElse));
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConditionals.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
similarity index 78%
rename from rxjava-core/src/main/java/rx/operators/OperationConditionals.java
rename to rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
index 06e14e4328..8424b90e02 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConditionals.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import java.util.Map;
+
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
@@ -29,32 +30,47 @@
  */
 public final class OperationConditionals {
     /** Utility class. */
-    private OperationConditionals() { throw new IllegalStateException("No instances!"); }
+    private OperationConditionals() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Return a subscription function that subscribes to an observable sequence
      * chosen from a map of observables via a selector function or to the
      * default observable.
-     * @param  the case key type
-     * @param  the result value type
-     * @param caseSelector the function that produces a case key when an Observer subscribes
-     * @param mapOfCases a map that maps a case key to an observable sequence
-     * @param defaultCase the default observable if the {@code mapOfCases} doesn't contain a value for
-     *                    the key returned by the {@case caseSelector}
+     * 
+     * @param 
+     *            the case key type
+     * @param 
+     *            the result value type
+     * @param caseSelector
+     *            the function that produces a case key when an Observer subscribes
+     * @param mapOfCases
+     *            a map that maps a case key to an observable sequence
+     * @param defaultCase
+     *            the default observable if the {@code mapOfCases} doesn't contain a value for
+     *            the key returned by the {@case caseSelector}
      * @return a subscription function
      */
     public static  OnSubscribeFunc switchCase(
-            Func0 caseSelector, 
-            Map> mapOfCases, 
+            Func0 caseSelector,
+            Map> mapOfCases,
             Observable defaultCase) {
         return new SwitchCase(caseSelector, mapOfCases, defaultCase);
     }
+
     /**
      * Return a subscription function that subscribes to either the
      * then or orElse Observables depending on a condition function.
-     * @param  the result value type
-     * @param condition the condition to decide which Observables to subscribe to
-     * @param then the Observable sequence to subscribe to if {@code condition} is {@code true}
-     * @param orElse the Observable sequence to subscribe to if {@code condition} is {@code false}
+     * 
+     * @param 
+     *            the result value type
+     * @param condition
+     *            the condition to decide which Observables to subscribe to
+     * @param then
+     *            the Observable sequence to subscribe to if {@code condition} is {@code true}
+     * @param orElse
+     *            the Observable sequence to subscribe to if {@code condition} is {@code false}
      * @return a subscription function
      */
     public static  OnSubscribeFunc ifThen(
@@ -63,40 +79,55 @@ public static  OnSubscribeFunc ifThen(
             Observable orElse) {
         return new IfThen(condition, then, orElse);
     }
+
     /**
      * Return a subscription function that subscribes to the source Observable,
      * then resubscribes only if the postCondition evaluates to true.
-     * @param  the result value type
-     * @param source the source Observable
-     * @param postCondition the post condition after the source completes
+     * 
+     * @param 
+     *            the result value type
+     * @param source
+     *            the source Observable
+     * @param postCondition
+     *            the post condition after the source completes
      * @return a subscription function.
      */
     public static  OnSubscribeFunc doWhile(Observable source, Func0 postCondition) {
         return new WhileDoWhile(source, TRUE, postCondition);
     }
+
     /**
      * Return a subscription function that subscribes and resubscribes to the source
      * Observable if the preCondition evaluates to true.
-     * @param  the result value type
-     * @param source the source Observable
-     * @param preCondition the condition to evaluate before subscribing to source, 
-     *                     and subscribe to source if it returns {@code true}
+     * 
+     * @param 
+     *            the result value type
+     * @param source
+     *            the source Observable
+     * @param preCondition
+     *            the condition to evaluate before subscribing to source,
+     *            and subscribe to source if it returns {@code true}
      * @return a subscription function.
      */
     public static  OnSubscribeFunc whileDo(Observable source, Func0 preCondition) {
         return new WhileDoWhile(source, preCondition, preCondition);
     }
+
     /**
      * Select an observable from a map based on a case key returned by a selector
      * function when an observer subscribes.
-     * @param  the case key type
-     * @param  the result value type
+     * 
+     * @param 
+     *            the case key type
+     * @param 
+     *            the result value type
      */
     private static final class SwitchCase implements OnSubscribeFunc {
         final Func0 caseSelector;
         final Map> mapOfCases;
         final Observable defaultCase;
-        public SwitchCase(Func0 caseSelector, 
+
+        public SwitchCase(Func0 caseSelector,
                 Map> mapOfCases,
                 Observable defaultCase) {
             this.caseSelector = caseSelector;
@@ -121,6 +152,7 @@ public Subscription onSubscribe(Observer t1) {
             return target.subscribe(t1);
         }
     }
+
     /** Returns always true. */
     private static final class Func0True implements Func0 {
         @Override
@@ -128,22 +160,28 @@ public Boolean call() {
             return true;
         }
     }
+
     /** Returns always true function. */
     private static final Func0True TRUE = new Func0True();
+
     /**
      * Given a condition, subscribe to one of the observables when an Observer
      * subscribes.
-     * @param  the result value type
+     * 
+     * @param 
+     *            the result value type
      */
     private static final class IfThen implements OnSubscribeFunc {
         final Func0 condition;
         final Observable then;
         final Observable orElse;
+
         public IfThen(Func0 condition, Observable then, Observable orElse) {
             this.condition = condition;
             this.then = then;
             this.orElse = orElse;
         }
+
         @Override
         public Subscription onSubscribe(Observer t1) {
             Observable target;
@@ -160,21 +198,24 @@ public Subscription onSubscribe(Observer t1) {
             return target.subscribe(t1);
         }
     }
+
     /**
      * Repeatedly subscribes to the source observable if the pre- or
      * postcondition is true.
      * 
    
      * This combines the While and DoWhile into a single operation through
      * the conditions.
-     * @param  the result value type
+     * 
+     * @param 
+     *            the result value type
      */
     private static final class WhileDoWhile implements OnSubscribeFunc {
         final Func0 preCondition;
         final Func0 postCondition;
         final Observable source;
-        public WhileDoWhile(Observable source, 
-                Func0 preCondition, Func0 postCondition
-                ) {
+
+        public WhileDoWhile(Observable source,
+                Func0 preCondition, Func0 postCondition) {
             this.source = source;
             this.preCondition = preCondition;
             this.postCondition = postCondition;
@@ -191,19 +232,21 @@ public Subscription onSubscribe(Observer t1) {
             }
             if (first) {
                 SerialSubscription ssub = new SerialSubscription();
-                
-                ssub.setSubscription(source.subscribe(new SourceObserver(t1, ssub)));
-                
+
+                ssub.set(source.subscribe(new SourceObserver(t1, ssub)));
+
                 return ssub;
             } else {
                 t1.onCompleted();
             }
             return Subscriptions.empty();
         }
+
         /** Observe the source. */
         final class SourceObserver implements Observer {
             final SerialSubscription cancel;
             final Observer observer;
+
             public SourceObserver(Observer observer, SerialSubscription cancel) {
                 this.observer = observer;
                 this.cancel = cancel;
@@ -236,7 +279,7 @@ public void onCompleted() {
                     cancel.unsubscribe();
                 }
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
similarity index 82%
rename from rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java
rename to rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
index 3daec59297..f6c4f09ad0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConditionalsTest.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
@@ -15,18 +15,23 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.*;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
+import rx.Statement;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
@@ -41,13 +46,14 @@ public class OperationConditionalsTest {
     Func0 condition;
     Func0 conditionError;
     int numRecursion = 250;
-    
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
         scheduler = new TestScheduler();
         func = new Func0() {
             int count = 1;
+
             @Override
             public Integer call() {
                 return count++;
@@ -55,6 +61,7 @@ public Integer call() {
         };
         funcError = new Func0() {
             int count = 1;
+
             @Override
             public Integer call() {
                 if (count == 2) {
@@ -65,15 +72,17 @@ public Integer call() {
         };
         condition = new Func0() {
             boolean r;
+
             @Override
             public Boolean call() {
                 r = !r;
                 return r;
             }
-            
+
         };
         conditionError = new Func0() {
             boolean r;
+
             @Override
             public Boolean call() {
                 r = !r;
@@ -82,9 +91,10 @@ public Boolean call() {
                 }
                 return r;
             }
-            
+
         };
     }
+
      Func0 just(final T value) {
         return new Func0() {
             @Override
@@ -93,129 +103,132 @@ public T call() {
             }
         };
     }
-    
+
     @SuppressWarnings("unchecked")
      void observe(Observable source, T... values) {
         Observer o = mock(Observer.class);
-        
+
         Subscription s = source.subscribe(o);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         for (T v : values) {
             inOrder.verify(o, times(1)).onNext(v);
         }
         inOrder.verify(o, times(1)).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
         s.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @SuppressWarnings("unchecked")
      void observeSequence(Observable source, Iterable values) {
         Observer o = mock(Observer.class);
-        
+
         Subscription s = source.subscribe(o);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         for (T v : values) {
             inOrder.verify(o, times(1)).onNext(v);
         }
         inOrder.verify(o, times(1)).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
         s.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @SuppressWarnings("unchecked")
      void observeError(Observable source, Class error, T... valuesBeforeError) {
         Observer o = mock(Observer.class);
-        
+
         Subscription s = source.subscribe(o);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         for (T v : valuesBeforeError) {
             inOrder.verify(o, times(1)).onNext(v);
         }
         inOrder.verify(o, times(1)).onError(any(error));
         verify(o, never()).onCompleted();
-        
+
         s.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @SuppressWarnings("unchecked")
      void observeSequenceError(Observable source, Class error, Iterable valuesBeforeError) {
         Observer o = mock(Observer.class);
-        
+
         Subscription s = source.subscribe(o);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         for (T v : valuesBeforeError) {
             inOrder.verify(o, times(1)).onNext(v);
         }
         inOrder.verify(o, times(1)).onError(any(error));
         verify(o, never()).onCompleted();
-        
+
         s.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void testSimple() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5, 6);
-        
+
         Map> map = new HashMap>();
         map.put(1, source1);
         map.put(2, source2);
-        
-        Observable result = Observable.switchCase(func, map);
+
+        Observable result = Statement.switchCase(func, map);
 
         observe(result, 1, 2, 3);
         observe(result, 4, 5, 6);
         observe(result);
     }
+
     @Test
     public void testDefaultCase() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5, 6);
-        
+
         Map> map = new HashMap>();
         map.put(1, source1);
-        
-        Observable result = Observable.switchCase(func, map, source2);
+
+        Observable result = Statement.switchCase(func, map, source2);
 
         observe(result, 1, 2, 3);
         observe(result, 4, 5, 6);
         observe(result, 4, 5, 6);
     }
+
     @Test
     public void testCaseSelectorThrows() {
         Observable source1 = Observable.from(1, 2, 3);
-        
+
         Map> map = new HashMap>();
         map.put(1, source1);
-        
-        Observable result = Observable.switchCase(funcError, map);
-        
+
+        Observable result = Statement.switchCase(funcError, map);
+
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
+
     @Test
     public void testMapGetThrows() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5, 6);
-        
+
         Map> map = new HashMap>() {
 
             @Override
@@ -225,20 +238,21 @@ public Observable get(Object key) {
                 }
                 return super.get(key);
             }
-            
+
         };
         map.put(1, source1);
         map.put(2, source2);
-        
-        Observable result = Observable.switchCase(func, map);
-        
+
+        Observable result = Statement.switchCase(func, map);
+
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
+
     @Test
     public void testMapContainsKeyThrows() {
         Observable source1 = Observable.from(1, 2, 3);
-        
+
         Map> map = new HashMap>() {
 
             @Override
@@ -248,133 +262,142 @@ public boolean containsKey(Object key) {
                 }
                 return super.containsKey(key);
             }
-            
+
         };
         map.put(1, source1);
-        
-        Observable result = Observable.switchCase(func, map);
-        
+
+        Observable result = Statement.switchCase(func, map);
+
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
+
     @Test
     public void testChosenObservableThrows() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Map> map = new HashMap>();
         map.put(1, source1);
         map.put(2, source2);
-        
-        Observable result = Observable.switchCase(func, map);
-        
+
+        Observable result = Statement.switchCase(func, map);
+
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
+
     @Test
     public void testIfThen() {
         Observable source1 = Observable.from(1, 2, 3);
-        
-        Observable result = Observable.ifThen(condition, source1);
+
+        Observable result = Statement.ifThen(condition, source1);
 
         observe(result, 1, 2, 3);
         observe(result);
         observe(result, 1, 2, 3);
         observe(result);
     }
-    
+
     @Test
     public void testIfThenElse() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5, 6);
-        
-        Observable result = Observable.ifThen(condition, source1, source2);
+
+        Observable result = Statement.ifThen(condition, source1, source2);
 
         observe(result, 1, 2, 3);
         observe(result, 4, 5, 6);
         observe(result, 1, 2, 3);
         observe(result, 4, 5, 6);
     }
-    
+
     @Test
     public void testIfThenConditonThrows() {
         Observable source1 = Observable.from(1, 2, 3);
-        
-        Observable result = Observable.ifThen(conditionError, source1);
+
+        Observable result = Statement.ifThen(conditionError, source1);
 
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
-    
+
     @Test
     public void testIfThenObservableThrows() {
         Observable source1 = Observable.error(new RuntimeException("Forced failure!"));
 
-        Observable result = Observable.ifThen(condition, source1);
-        
+        Observable result = Statement.ifThen(condition, source1);
+
         observeError(result, RuntimeException.class);
         observe(result);
 
         observeError(result, RuntimeException.class);
         observe(result);
     }
+
     @Test
     public void testIfThenElseObservableThrows() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.error(new RuntimeException("Forced failure!"));
 
-        Observable result = Observable.ifThen(condition, source1, source2);
-        
+        Observable result = Statement.ifThen(condition, source1, source2);
+
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
         observe(result, 1, 2, 3);
         observeError(result, RuntimeException.class);
     }
-    
+
     @Test
     public void testDoWhile() {
         Observable source1 = Observable.from(1, 2, 3);
-        
-        Observable result = source1.doWhile(condition);
-        
+
+        Observable result = Statement.doWhile(source1, condition);
+
         observe(result, 1, 2, 3, 1, 2, 3);
     }
+
     @Test
     public void testDoWhileOnce() {
         Observable source1 = Observable.from(1, 2, 3);
-        
+
         condition.call(); // toggle to false
-        Observable result = source1.doWhile(condition);
-        
+        Observable result = Statement.doWhile(source1, condition);
+
         observe(result, 1, 2, 3);
     }
+
     @Test
     public void testDoWhileConditionThrows() {
         Observable source1 = Observable.from(1, 2, 3);
-        Observable result = source1.doWhile(conditionError);
-        
+        Observable result = Statement.doWhile(source1, conditionError);
+
         observeError(result, RuntimeException.class, 1, 2, 3);
     }
+
     @Test
     public void testDoWhileSourceThrows() {
-        Observable source1 = Observable.concat(Observable.from(1, 2, 3), 
-                Observable.error(new RuntimeException("Forced failure!")));
-        
-        Observable result = source1.doWhile(condition);
+        Observable source1 = Observable.concat(Observable.from(1, 2, 3),
+                Observable. error(new RuntimeException("Forced failure!")));
+
+        Observable result = Statement.doWhile(source1, condition);
 
         observeError(result, RuntimeException.class, 1, 2, 3);
     }
-    Func0 countdown(final int n) { 
+
+    Func0 countdown(final int n) {
         return new Func0() {
             int count = n;
+
             @Override
             public Boolean call() {
                 return count-- > 0;
             }
         };
     }
+
     @Test
     public void testDoWhileManyTimes() {
         Observable source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread());
@@ -385,32 +408,36 @@ public void testDoWhileManyTimes() {
             expected.add(2);
             expected.add(3);
         }
-        
-        Observable result = source1.doWhile(countdown(numRecursion));
-        
+
+        Observable result = Statement.doWhile(source1, countdown(numRecursion));
+
         observeSequence(result, expected);
     }
+
     @Test
     public void testWhileDo() {
         Observable source1 = Observable.from(1, 2, 3);
-        Observable result = source1.whileDo(countdown(2));
-        
+        Observable result = Statement.whileDo(source1, countdown(2));
+
         observe(result, 1, 2, 3, 1, 2, 3);
     }
+
     @Test
     public void testWhileDoOnce() {
         Observable source1 = Observable.from(1, 2, 3);
-        Observable result = source1.whileDo(countdown(1));
-        
+        Observable result = Statement.whileDo(source1, countdown(1));
+
         observe(result, 1, 2, 3);
     }
+
     @Test
     public void testWhileDoZeroTimes() {
         Observable source1 = Observable.from(1, 2, 3);
-        Observable result = source1.whileDo(countdown(0));
-        
+        Observable result = Statement.whileDo(source1, countdown(0));
+
         observe(result);
     }
+
     @Test
     public void testWhileDoManyTimes() {
         Observable source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread());
@@ -421,32 +448,35 @@ public void testWhileDoManyTimes() {
             expected.add(2);
             expected.add(3);
         }
-        
-        Observable result = source1.whileDo(countdown(numRecursion));
-        
+
+        Observable result = Statement.whileDo(source1, countdown(numRecursion));
+
         observeSequence(result, expected);
     }
+
     @Test
     public void testWhileDoConditionThrows() {
         Observable source1 = Observable.from(1, 2, 3);
-        Observable result = source1.whileDo(conditionError);
-        
+        Observable result = Statement.whileDo(source1, conditionError);
+
         observeError(result, RuntimeException.class, 1, 2, 3);
     }
+
     @Test
     public void testWhileDoConditionThrowsImmediately() {
         Observable source1 = Observable.from(1, 2, 3);
         conditionError.call();
-        Observable result = source1.whileDo(conditionError);
-        
+        Observable result = Statement.whileDo(source1, conditionError);
+
         observeError(result, RuntimeException.class);
     }
+
     @Test
     public void testWhileDoSourceThrows() {
-        Observable source1 = Observable.concat(Observable.from(1, 2, 3), 
-                Observable.error(new RuntimeException("Forced failure!")));
-        
-        Observable result = source1.whileDo(condition);
+        Observable source1 = Observable.concat(Observable.from(1, 2, 3),
+                Observable. error(new RuntimeException("Forced failure!")));
+
+        Observable result = Statement.whileDo(source1, condition);
 
         observeError(result, RuntimeException.class, 1, 2, 3);
     }
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e311414af8..80bc473bc5 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -15,7 +15,6 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
 import static rx.util.functions.Functions.*;
 
 import java.util.ArrayList;
@@ -43,7 +42,6 @@
 import rx.operators.OperationCast;
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
-import rx.operators.OperationConditionals;
 import rx.operators.OperationDebounce;
 import rx.operators.OperationDefaultIfEmpty;
 import rx.operators.OperationDefer;
@@ -1995,164 +1993,6 @@ public static  Observable switchLatest(Observable
-     * 
-     *
-     * @param  the case key type
-     * @param  the result value type
-     * @param caseSelector the function that produces a case key when an
-     *                     Observer subscribes
-     * @param mapOfCases a map that maps a case key to an Observable
-     * @return a particular Observable chosen by key from the map of
-     *         Observables, or an empty Observable if no Observable matches the
-     *         key
-     */
-    public static  Observable switchCase(Func0 caseSelector, 
-            Map> mapOfCases) {
-        return switchCase(caseSelector, mapOfCases, Observable.empty());
-    }
-    
-    /**
-     * Return a particular one of several possible Observables based on a case
-     * selector and run it on the designated scheduler.
-     * 
    
-     * 
-     *
-     * @param  the case key type
-     * @param  the result value type
-     * @param caseSelector the function that produces a case key when an
-     *                     Observer subscribes
-     * @param mapOfCases a map that maps a case key to an Observable
-     * @param scheduler the scheduler where the empty observable is observed
-     * @return a particular Observable chosen by key from the map of
-     *         Observables, or an empty Observable if no Observable matches the
-     *         key, but one that runs on the designated scheduler in either case
-     */
-    public static  Observable switchCase(Func0 caseSelector, 
-            Map> mapOfCases, Scheduler scheduler) {
-        return switchCase(caseSelector, mapOfCases, Observable.empty(scheduler));
-    }
-    /**
-     * Return a particular one of several possible Observables based on a case
-     * selector, or a default Observable if the case selector does not map to
-     * a particular one.
-     * 
    
-     * 
-     *
-     * @param  the case key type
-     * @param  the result value type
-     * @param caseSelector the function that produces a case key when an
-     *                     Observer subscribes
-     * @param mapOfCases a map that maps a case key to an Observable
-     * @param defaultCase the default Observable if the {@code mapOfCases}
-     *                    doesn't contain a value for the key returned by the
-     *                    {@case caseSelector}
-     * @return a particular Observable chosen by key from the map of
-     *         Observables, or the default case if no Observable matches the key
-     */
-    public static  Observable switchCase(Func0 caseSelector, 
-            Map> mapOfCases, 
-            Observable defaultCase) {
-        return create(OperationConditionals.switchCase(caseSelector, mapOfCases, defaultCase));
-    }
-    
-    /**
-     * Return an Observable that replays the emissions from the source
-     * Observable, and then continues to replay them so long as a condtion is
-     * true.
-     * 
    
-     * 
-     *
-     * @param postCondition the post condition to test after the source
-     *                      Observable completes
-     * @return an Observable that replays the emissions from the source
-     *         Observable, and then continues to replay them so long as the post
-     *         condition is true
-     */
-    public Observable doWhile(Func0 postCondition) {
-        return create(OperationConditionals.doWhile(this, postCondition));
-    }
-    
-    /**
-     * Return an Observable that replays the emissions from the source
-     * Observable so long as a condtion is true.
-     * 
    
-     * 
-     *
-     * @param preCondition the condition to evaluate before subscribing to or
-     *                     replaying the source Observable
-     * @return an Observable that replays the emissions from the source
-     *         Observable so long as preCondition is true
-     */
-    public Observable whileDo(Func0 preCondition) {
-        return create(OperationConditionals.whileDo(this, preCondition));
-    }
-    
-    /**
-     * Return an Observable that emits the emissions from a specified Observable
-     * if a condition evaluates to true, otherwise return an empty Observable.
-     * 
    
-     * 
-     *
-     * @param  the result value type
-     * @param condition the condition that decides whether to emit the emissions
-     *                  from the then Observable
-     * @param then the Observable sequence to emit to if {@code condition} is
-     *             {@code true}
-     * @return an Observable that mimics the {@code then} Observable if the
-     *         {@code condition} function evaluates to true, or an empty
-     *         Observable otherwise
-     */
-    public static  Observable ifThen(Func0 condition, Observable then) {
-        return ifThen(condition, then, Observable.empty());
-    }
-    
-    /**
-     * Return an Observable that emits the emissions from a specified Observable
-     * if a condition evaluates to true, otherwise return an empty Observable
-     * that runs on a specified Scheduler.
-     * 
    
-     * 
-     *
-     * @param  the result value type
-     * @param condition the condition that decides whether to emit the emissions
-     *                  from the then Observable
-     * @param then the Observable sequence to emit to if {@code condition} is
-     *             {@code true}
-     * @param scheduler the Scheduler on which the empty Observable runs if the
-     *                  in case the condition returns false
-     * @return an Observable that mimics the {@code then} Observable if the
-     *         {@code condition} function evaluates to true, or an empty
-     *         Observable running on the specified Scheduler otherwise
-     */
-    public static  Observable ifThen(Func0 condition, Observable then, Scheduler scheduler) {
-        return ifThen(condition, then, Observable.empty(scheduler));
-    }
-
-    /**
-     * Return an Observable that emits the emissions from one specified
-     * Observable if a condition evaluates to true, or from another specified
-     * Observable otherwise.
-     * 
    
-     * 
-     *
-     * @param  the result value type
-     * @param condition the condition that decides which Observable to emit the
-     *                  emissions from
-     * @param then the Observable sequence to emit to if {@code condition} is
-     *             {@code true}
-     * @param orElse the Observable sequence to emit to if {@code condition} is
-     *               {@code false}
-     * @return an Observable that mimics either the {@code then} or
-     *         {@code orElse} Observables depending on a condition function
-     */
-    public static  Observable ifThen(Func0 condition, Observable then,
-            Observable orElse) {
-        return create(OperationConditionals.ifThen(condition, then, orElse));
-    }
     
     /**
      * Accepts an Observable and wraps it in another Observable that ensures
diff --git a/settings.gradle b/settings.gradle
index c40f29adb6..22dd94ec82 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,4 +9,5 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
-'rxjava-contrib:rxjava-async-util'
+'rxjava-contrib:rxjava-async-util', \
+'rxjava-contrib:rxjava-computation-expressions'

From 425df5f73345b43eccc188d44393aa4c0e6b83f9 Mon Sep 17 00:00:00 2001
From: y-p 
Date: Fri, 3 Jan 2014 01:21:47 +0200
Subject: [PATCH 177/441] Add missing type hint to clojure example

Following GH623
---
 .../examples/clojure/rx/lang/clojure/examples/rx_examples.clj | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
index 5b9d1df94d..403a9b4495 100644
--- a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
+++ b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
@@ -27,7 +27,9 @@
 
 (defn hello
   [& args]
-  (-> (Observable/from args)
+  (->
+    ; type hint required due to `Observable/from` overloading
+    (Observable/from ^java.lang.Iterable args)
     (.subscribe (rx/action [v] (println (str "Hello " v "!"))))))
 
 ; To see output

From 679a88fdae553bbab0c841bb0df66e294e90ffaa Mon Sep 17 00:00:00 2001
From: headinthebox 
Date: Thu, 2 Jan 2014 21:29:11 -0800
Subject: [PATCH 178/441] Added ConnectableObservable Fixed test Added overload
 for scan Added trivial test for scan

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 12 +++---
 .../main/scala/rx/lang/scala/Observable.scala | 37 ++++++++++++++----
 .../observables/BlockingObservable.scala      |  1 +
 .../observables/ConnectableObservable.scala   | 38 +++++++++++++++++++
 .../scala/rx/lang/scala/ObservableTest.scala  |  8 ++++
 5 files changed, 83 insertions(+), 13 deletions(-)
 create mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/ConnectableObservable.scala

diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
index 7bf832f58e..048df5dc74 100644
--- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
+++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
@@ -243,9 +243,9 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def olympicsExample() {
-    val (go, medals) = Olympics.mountainBikeMedals.publish
+    val medals = Olympics.mountainBikeMedals.publish
     medals.subscribe(println(_))
-    go()
+    medals.connect
     //waitFor(medals)
   }
 
@@ -257,10 +257,10 @@ class RxScalaDemo extends JUnitSuite {
 
   @Test def exampleWithPublish() {
     val unshared = List(1 to 4).toObservable
-    val (startFunc, shared) = unshared.publish
+    val shared = unshared.publish
     shared.subscribe(n => println(s"subscriber 1 gets $n"))
     shared.subscribe(n => println(s"subscriber 2 gets $n"))
-    startFunc()
+    shared.connect
   }
 
   def doLater(waitTime: Duration, action: () => Unit): Unit = {
@@ -269,9 +269,9 @@ class RxScalaDemo extends JUnitSuite {
 
   @Test def exampleWithoutReplay() {
     val numbers = Observable.interval(1000 millis).take(6)
-    val (startFunc, sharedNumbers) = numbers.publish
+    val sharedNumbers = numbers.publish
     sharedNumbers.subscribe(n => println(s"subscriber 1 gets $n"))
-    startFunc()
+    sharedNumbers.connect
     // subscriber 2 misses 0, 1, 2!
     doLater(3500 millis, () => { sharedNumbers.subscribe(n => println(s"subscriber 2 gets $n")) })
     waitFor(sharedNumbers)
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index 9be58009dd..a39754e593 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -18,7 +18,7 @@ package rx.lang.scala
 
 import rx.util.functions.FuncN
 import rx.Observable.OnSubscribeFunc
-
+import rx.lang.scala.observables.ConnectableObservable
 
 
 /**
@@ -1052,12 +1052,10 @@ trait Observable[+T]
    *
    * 
    *
-   * @return a pair of a start function and an [[rx.lang.scala.Observable]] such that when the start function
-   *         is called, the Observable starts to emit items to its [[rx.lang.scala.Observer]]s
+   * @return an [[rx.lang.scala.observables.ConnectableObservable]].
    */
-  def publish: (() => Subscription, Observable[T]) = {
-    val javaCO = asJavaObservable.publish()
-    (() => javaCO.connect(), toScalaObservable[T](javaCO))
+  def publish: ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.publish())
   }
 
   // TODO add Scala-like aggregate function
@@ -1136,7 +1134,8 @@ trait Observable[+T]
    *            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 [[rx.lang.scala.Observer]]s via [[rx.lang.scala.Observer.onNext onNext]] and used in the next accumulator call.
+   *            Observable, whose result will be emitted to [[rx.lang.scala.Observer]]s via
+   *            [[rx.lang.scala.Observer.onNext onNext]] and used in the next accumulator call.
    * @return an Observable that emits the results of each call to the accumulator function
    */
   def scan[R](initialValue: R)(accumulator: (R, T) => R): Observable[R] = {
@@ -1145,6 +1144,30 @@ trait Observable[+T]
     }))
   }
 
+  /**
+   * 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.
+   * 
    
+   * 
+   * 
    
+   *
+   * @param accumulator
+   *            an accumulator function to be invoked on each item emitted by the source
+   *            Observable, whose result will be emitted to [[rx.lang.scala.Observer]]s via
+   *            [[rx.lang.scala.Observer.onNext onNext]] and used in the next accumulator call.
+   * @return
+   *         an Observable that emits the results of each call to the
+   *         accumulator function
+   */
+  def scan[U >: T](accumulator: (U, U) => U): Observable[U] = {
+    val func: Func2[_ >: U, _ >: U, _ <: U] = accumulator
+    val func2 = func.asInstanceOf[Func2[T, T, T]]
+    toScalaObservable[U](asJavaObservable.asInstanceOf[rx.Observable[T]].scan(func2))
+  }
+
   /**
    * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by
    * the source Observable satisfy a condition.
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/BlockingObservable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/BlockingObservable.scala
index f9e98efa63..c1ce913095 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/BlockingObservable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/BlockingObservable.scala
@@ -18,6 +18,7 @@ package rx.lang.scala.observables
 import scala.collection.JavaConverters._
 import rx.lang.scala.ImplicitFunctionConversions._
 
+
 /**
  * An Observable that provides blocking operators.
  * 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/ConnectableObservable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/ConnectableObservable.scala
new file mode 100644
index 0000000000..bba27ecb22
--- /dev/null
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/observables/ConnectableObservable.scala
@@ -0,0 +1,38 @@
+/**
+ * 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.lang.scala.observables
+
+import rx.lang.scala.{Observable, Subscription}
+import rx.lang.scala.JavaConversions._
+
+class ConnectableObservable[+T] private[scala](val asJavaObservable: rx.observables.ConnectableObservable[_ <: T])
+  extends Observable[T] {
+
+  /**
+   * Call a ConnectableObservable's connect method to instruct it to begin emitting the
+   * items from its underlying [[rx.lang.scala.Observable]] to its [[rx.lang.scala.Observer]]s.
+   */
+  def connect: Subscription = toScalaSubscription(asJavaObservable.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 [[rx.lang.scala.Observable]]
+   */
+  def refCount: Observable[T] = toScalaObservable[T](asJavaObservable.refCount())
+}
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala
index 39f863b4dd..c0e575f4d0 100644
--- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala
+++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala
@@ -57,6 +57,14 @@ class ObservableTests extends JUnitSuite {
     assertEquals(demat.toBlockingObservable.toIterable.toList, List(1, 2, 3))
 }
 
+  @Test def TestScan() {
+     val xs = Observable.items(0,1,2,3)
+     val ys = xs.scan(0)(_+_)
+     assertEquals(List(0,0,1,3,6), ys.toBlockingObservable.toList)
+     val zs = xs.scan((x: Int, y:Int) => x*y)
+     assertEquals(List(0, 0, 0, 0), zs.toBlockingObservable.toList)
+  }
+
   // Test that Java's firstOrDefault propagates errors.
   // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse
   // should be changed accordingly.

From c030321bcffbebc654b414160a4cd425031f150f Mon Sep 17 00:00:00 2001
From: hura 
Date: Sat, 4 Jan 2014 11:53:49 -0500
Subject: [PATCH 179/441] Added `Observable.timeout` wrappers to scala adapter

Added the four timeout methods on Observable in the Scala adaptor. Note
for the java/scala type interop:
http://stackoverflow.com/q/20912151
---
 .../main/scala/rx/lang/scala/Observable.scala | 83 ++++++++++++++++++-
 1 file changed, 79 insertions(+), 4 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index a39754e593..560cea3a18 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -1600,6 +1600,81 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.throttleLast(intervalDuration.length, intervalDuration.unit, scheduler))
   }
 
+  /**
+   * Applies a timeout policy for each item emitted by the Observable, using
+   * the specified scheduler to run timeout timers. If the next item isn't
+   * observed within the specified timeout duration starting from its
+   * predecessor, observers are notified of a `TimeoutException`.
+   * 
    
+   * 
+   *
+   * @param timeout maximum duration between items before a timeout occurs
+   * @return the source Observable modified to notify observers of a
+   *         `TimeoutException` in case of a timeout
+   */
+  def timeout(timeout: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.timeout(timeout.length, timeout.unit))
+  }
+
+  /**
+   * Applies a timeout policy for each item emitted by the Observable, using
+   * the specified scheduler to run timeout timers. If the next item isn't
+   * observed within the specified timeout duration starting from its
+   * predecessor, a specified fallback Observable produces future items and
+   * notifications from that point on.
+   * 
    
+   * 
+   *
+   * @param timeout maximum duration between items before a timeout occurs
+   * @param other fallback Observable to use in case of a timeout
+   * @return the source Observable modified to switch to the fallback
+   *         Observable in case of a timeout
+   */
+  def timeout[U >: T](timeout: Duration, other: Observable[U]): Observable[U] = {
+    val otherJava: rx.Observable[_ <: U] = other.asJavaObservable
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable[U](thisJava.timeout(timeout.length, timeout.unit, otherJava))
+  }
+
+  /**
+   * Applies a timeout policy for each item emitted by the Observable, using
+   * the specified scheduler to run timeout timers. If the next item isn't
+   * observed within the specified timeout duration starting from its
+   * predecessor, the observer is notified of a `TimeoutException`.
+   * 
    
+   * 
+   *
+   * @param timeout maximum duration between items before a timeout occurs
+   * @param scheduler Scheduler to run the timeout timers on
+   * @return the source Observable modified to notify observers of a
+   *         `TimeoutException` in case of a timeout
+   */
+  def timeout(timeout: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.timeout(timeout.length, timeout.unit, scheduler.asJavaScheduler))
+  }
+
+  /**
+   * Applies a timeout policy for each item emitted by the Observable, using
+   * the specified scheduler to run timeout timers. If the next item isn't
+   * observed within the specified timeout duration starting from its
+   * predecessor, a specified fallback Observable sequence produces future
+   * items and notifications from that point on.
+   * 
    
+   * 
+   *
+   * @param timeout maximum duration between items before a timeout occurs
+   * @param other Observable to use as the fallback in case of a timeout
+   * @param scheduler Scheduler to run the timeout timers on
+   * @return the source Observable modified so that it will switch to the
+   *         fallback Observable in case of a timeout
+   */
+  def timeout[U >: T](timeout: Duration, other: Observable[U], scheduler: Scheduler): Observable[U] = {
+    val otherJava: rx.Observable[_ <: U] = other.asJavaObservable
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable[U](thisJava.timeout(timeout.length, timeout.unit, otherJava, scheduler.asJavaScheduler))
+  }
+
+
   /**
    * Returns an Observable that sums up the elements of this Observable.
    *
@@ -1894,10 +1969,10 @@ trait Observable[+T]
   }
 
   /**
-   * Invokes an action if the source Observable calls onError.
+   * Invokes an action if the source Observable calls `onError`.
    *
    * @param onError the action to invoke if the source Observable calls
-   *                onError
+   *                `onError`
    * @return the source Observable with the side-effecting behavior applied
    */
   def doOnError(onError: Throwable => Unit): Observable[T] = {
@@ -1905,10 +1980,10 @@ trait Observable[+T]
   }
 
   /**
-   * Invokes an action when the source Observable calls onCompleted.
+   * Invokes an action when the source Observable calls `onCompleted`.
    *
    * @param onCompleted the action to invoke when the source Observable calls
-   *                    onCompleted
+   *                    `onCompleted`
    * @return the source Observable with the side-effecting behavior applied
    */
   def doOnCompleted(onCompleted: () => Unit): Observable[T] = {

From e36e7174773a9e5d5895e8259d1f3e52bc6b4892 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 6 Jan 2014 12:08:22 -0800
Subject: [PATCH 180/441] =?UTF-8?q?Deprecate=20multiple=20arity=20?=
 =?UTF-8?q?=E2=80=98from=E2=80=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- added @Deprecated annotations where it was only part of the Javadoc
- deprecated ‘where’ which is a duplicate of `filter` kept from early days matching Rx.Net
---
 rxjava-core/src/main/java/rx/Observable.java | 27 ++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 80bc473bc5..787611dc49 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -849,7 +849,9 @@ public static  Observable from(T t1) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}
      */
+    @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
     public static  Observable from(T t1, T t2) {
@@ -873,7 +875,9 @@ public static  Observable from(T t1, T t2) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
     public static  Observable from(T t1, T t2, T t3) {
@@ -898,7 +902,9 @@ public static  Observable from(T t1, T t2, T t3) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
     public static  Observable from(T t1, T t2, T t3, T t4) {
@@ -924,7 +930,9 @@ public static  Observable from(T t1, T t2, T t3, T t4) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -951,7 +959,9 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -979,7 +989,9 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -1008,7 +1020,9 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -1038,7 +1052,9 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -1064,7 +1080,9 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
+    @Deprecated
     @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) {
@@ -1175,7 +1193,9 @@ public static  Observable defer(Func0> o
      * @param  the type of that item
      * @return an Observable that emits a single item and then completes
      * @see RxJava Wiki: just()
+     * @deprecated Use {@link #from(T)}
      */
+    @Deprecated
     public static  Observable just(T value) {
         return from(Arrays.asList((value)));
     }
@@ -1194,7 +1214,9 @@ public static  Observable just(T value) {
      * @return an Observable that emits a single item and then completes, on a
      *         specified scheduler
      * @see RxJava Wiki: just()
+     * @deprecated Use {@link #from(T)}
      */
+    @Deprecated
     public static  Observable just(T value, Scheduler scheduler) {
         return from(Arrays.asList((value)), scheduler);
     }
@@ -3898,6 +3920,7 @@ public  Observable switchMap(Func1RxJava Wiki: where()
      * @see #filter(Func1)
      */
+    @Deprecated
     public Observable where(Func1 predicate) {
         return filter(predicate);
     }
@@ -3935,6 +3958,7 @@ public  Observable map(Func1 func) {
      * @see MSDN: Observable.Select
      * @deprecated just use zip with {@link Observable#range(int)}
      */
+    @Deprecated
     public  Observable mapWithIndex(Func2 func) {
         return create(OperationMap.mapWithIndex(this, func));
     }
@@ -3959,6 +3983,7 @@ public  Observable mapWithIndex(Func2 fun
      * @see #flatMap(Func1)
      * @deprecated
      */
+    @Deprecated
     public  Observable mapMany(Func1> func) {
         return mergeMap(func);
     }
@@ -5237,6 +5262,7 @@ public ConnectableObservable publishLast() {
      * @see #reduce(Func2)
      * @deprecated use #reduce(Func2)
      */
+    @Deprecated
     public Observable aggregate(Func2 accumulator) {
         return reduce(accumulator);
     }
@@ -5303,6 +5329,7 @@ public R call(R state, T value) {
      * @see #reduce(Object, Func2)
      * @deprecated use #reduce(Object, Func2)
      */
+    @Deprecated
     public  Observable aggregate(R initialValue, Func2 accumulator) {
         return reduce(initialValue, accumulator);
     }

From 5db1b0d832bae69c8274e71005568fc1dc259ead Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 6 Jan 2014 13:24:51 -0800
Subject: [PATCH 181/441] Revert use of CurrentThreadScheduler for
 Observable.from
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use ImmediateScheduler as performance is 4x faster and CurrentThreadScheduler currently offers no benefit (it doesn’t solve the unsubscribe problem).

Performance numbers:

     * Observable.from(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L), scheduler);
     *
     * --- Schedulers.immediate() ---
     *
     * Run: 0 - 1,849,947 ops/sec
     * Run: 1 - 2,076,067 ops/sec
     * Run: 2 - 2,114,688 ops/sec
     * Run: 3 - 2,114,301 ops/sec
     * Run: 4 - 2,102,543 ops/sec
     *
     * --- Schedulers.currentThread() ---
     *
     * Run: 0 - 548,862 ops/sec
     * Run: 1 - 559,955 ops/sec
     * Run: 2 - 581,412 ops/sec
     * Run: 3 - 562,187 ops/sec
     * Run: 4 - 565,723 ops/sec

     * Observable.from(Arrays.asList(1L), scheduler);
     *
     * --- Schedulers.immediate() ---
     *
     * Run: 10 - 4,113,672 ops/sec
     * Run: 11 - 4,068,351 ops/sec
     * Run: 12 - 4,070,318 ops/sec
     * Run: 13 - 4,161,793 ops/sec
     * Run: 14 - 4,156,725 ops/sec
     *
     * --- Schedulers.currentThread() ---
     *
     * Run: 10 - 1,692,286 ops/sec
     * Run: 11 - 1,765,054 ops/sec
     * Run: 12 - 1,763,100 ops/sec
     * Run: 13 - 1,770,907 ops/sec
     * Run: 14 - 1,732,291 ops/sec
---
 rxjava-core/src/main/java/rx/Observable.java  |   2 +-
 .../OperationToObservableIterable.java        |   2 +-
 .../schedulers/SchedulerPerformanceTests.java | 175 ++++++++++++++++++
 3 files changed, 177 insertions(+), 2 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 787611dc49..92fb348879 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -748,7 +748,7 @@ public static  Observable error(Throwable exception, Scheduler scheduler)
      * @see RxJava Wiki: from()
      */
     public static  Observable from(Iterable iterable) {
-        return from(iterable, Schedulers.currentThread());
+        return from(iterable, Schedulers.immediate());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
index 4297af00ae..7fb5f0ec91 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
@@ -41,7 +41,7 @@ public static  OnSubscribeFunc toObservableIterable(Iterable
     }
 
     public static  OnSubscribeFunc toObservableIterable(Iterable list) {
-        return toObservableIterable(list, Schedulers.currentThread());
+        return toObservableIterable(list, Schedulers.immediate());
     }
 
     private static class ToObservableIterable implements OnSubscribeFunc {
diff --git a/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java
new file mode 100644
index 0000000000..1f166dbfa6
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java
@@ -0,0 +1,175 @@
+/**
+ * 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.schedulers;
+
+import java.util.Arrays;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
+import rx.util.functions.Action0;
+
+public class SchedulerPerformanceTests {
+
+    private static final int REPETITIONS = 5 * 1000 * 1000;
+    private static final int NUM_PRODUCERS = 1;
+
+    public static void main(String args[]) {
+
+        final SchedulerPerformanceTests spt = new SchedulerPerformanceTests();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    //                    spt.singleResponse(Schedulers.immediate());
+                    //                    spt.singleResponse(Schedulers.currentThread());
+                    //                    spt.singleResponse(Schedulers.threadPoolForComputation());
+
+                    spt.arrayResponse(Schedulers.immediate());
+                    //                    spt.arrayResponse(Schedulers.currentThread());
+                    //                    spt.arrayResponse(Schedulers.threadPoolForComputation());
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    private void runTest(Action0 action) throws InterruptedException {
+        for (int runNum = 0; runNum < 15; runNum++) {
+            System.gc();
+            Thread.sleep(1000L);
+
+            final long start = System.nanoTime();
+
+            action.call();
+
+            long duration = System.nanoTime() - start;
+            long opsPerSec = (REPETITIONS * NUM_PRODUCERS * 1000L * 1000L * 1000L) / duration;
+            System.out.printf("Run: %d - %,d ops/sec \n",
+                    Integer.valueOf(runNum),
+                    Long.valueOf(opsPerSec));
+        }
+    }
+
+    /**
+     * Baseline ops/second without a subject.
+     * 
+     * Perf along this order of magnitude:
+     * 
+     * Run: 10 - 316,235,532 ops/sec
+     * Run: 11 - 301,886,792 ops/sec
+     * Run: 12 - 310,472,228 ops/sec
+     * Run: 13 - 313,469,797 ops/sec
+     * Run: 14 - 305,380,809 ops/sec
+     */
+    public long baseline() {
+        LongObserver o = new LongObserver();
+        for (long l = 0; l < REPETITIONS; l++) {
+            o.onNext(l);
+        }
+        o.onCompleted();
+        return o.sum;
+    }
+
+    /**
+     * Observable.from(Arrays.asList(1L), scheduler);
+     * 
+     * --- Schedulers.immediate() ---
+     * 
+     * Run: 10 - 4,113,672 ops/sec
+     * Run: 11 - 4,068,351 ops/sec
+     * Run: 12 - 4,070,318 ops/sec
+     * Run: 13 - 4,161,793 ops/sec
+     * Run: 14 - 4,156,725 ops/sec
+     * 
+     * --- Schedulers.currentThread() ---
+     * 
+     * Run: 10 - 1,692,286 ops/sec
+     * Run: 11 - 1,765,054 ops/sec
+     * Run: 12 - 1,763,100 ops/sec
+     * Run: 13 - 1,770,907 ops/sec
+     * Run: 14 - 1,732,291 ops/sec
+     * 
+     * --- Schedulers.computation() ---
+     * 
+     * Run: 0 - 224,004 ops/sec
+     * Run: 1 - 227,101 ops/sec
+     * 
+     */
+    public long singleResponse(Scheduler scheduler) {
+        Observable s = Observable.from(Arrays.asList(1L), scheduler);
+        LongObserver o = new LongObserver();
+
+        for (long l = 0; l < REPETITIONS; l++) {
+            s.subscribe(o);
+        }
+        return o.sum;
+    }
+
+    /**
+     * Observable.from(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L), scheduler);
+     * 
+     * --- Schedulers.immediate() ---
+     * 
+     * Run: 0 - 1,849,947 ops/sec
+     * Run: 1 - 2,076,067 ops/sec
+     * Run: 2 - 2,114,688 ops/sec
+     * Run: 3 - 2,114,301 ops/sec
+     * Run: 4 - 2,102,543 ops/sec
+     * 
+     * --- Schedulers.currentThread() ---
+     * 
+     * Run: 0 - 548,862 ops/sec
+     * Run: 1 - 559,955 ops/sec
+     * Run: 2 - 581,412 ops/sec
+     * Run: 3 - 562,187 ops/sec
+     * Run: 4 - 565,723 ops/sec
+     * 
+     */
+    public long arrayResponse(Scheduler scheduler) {
+        Observable s = Observable.from(Arrays.asList(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L), scheduler);
+        LongObserver o = new LongObserver();
+
+        for (long l = 0; l < REPETITIONS; l++) {
+            s.subscribe(o);
+        }
+        return o.sum;
+    }
+
+    private static class LongObserver implements Observer {
+
+        long sum = 0;
+
+        @Override
+        public void onCompleted() {
+
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            throw new RuntimeException(e);
+        }
+
+        @Override
+        public void onNext(Long l) {
+            sum += l;
+        }
+    }
+
+}

From e2c31c2c1002e948b8bf4de33cbac680f60da403 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 6 Jan 2014 13:28:26 -0800
Subject: [PATCH 182/441] Simpler computation/io naming for Schedulers

- simpler (no one remembers the current names when talking about them)
- does not tie naming to a particular implementation involving thread pools versus a pool of event loops or something similar (as we likely will change the implementation, see https://github.com/Netflix/RxJava/issues/713)
---
 .../main/java/rx/schedulers/Schedulers.java   | 36 +++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index b0c6a0cc9b..6247c3f54a 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -89,13 +89,28 @@ public static Scheduler executor(ScheduledExecutorService executor) {
      * 
    
      * This can be used for event-loops, processing callbacks and other computational work.
      * 
    
-     * Do not perform IO-bound work on this scheduler. Use {@link #threadPoolForComputation()} instead.
+     * Do not perform IO-bound work on this scheduler. Use {@link #io()} instead.
      * 
      * @return {@link ExecutorScheduler} for computation-bound work.
+     * @Deprecated Use {@link #computation()}
      */
+    @Deprecated
     public static Scheduler threadPoolForComputation() {
         return executor(COMPUTATION_EXECUTOR);
     }
+    
+    /**
+     * {@link Scheduler} intended for computational work.
+     * 
    
+     * This can be used for event-loops, processing callbacks and other computational work.
+     * 
    
+     * Do not perform IO-bound work on this scheduler. Use {@link #io()} instead.
+     * 
+     * @return {@link Scheduler} for computation-bound work.
+     */
+    public static Scheduler computation() {
+        return executor(COMPUTATION_EXECUTOR);
+    }
 
     /**
      * {@link Scheduler} intended for IO-bound work.
@@ -104,13 +119,30 @@ public static Scheduler threadPoolForComputation() {
      * 
    
      * This can be used for asynchronously performing blocking IO.
      * 
    
-     * Do not perform computational work on this scheduler. Use {@link #threadPoolForComputation()} instead.
+     * Do not perform computational work on this scheduler. Use {@link #computation()} instead.
      * 
      * @return {@link ExecutorScheduler} for IO-bound work.
+     * @deprecated Use {@link #io()} instead.
      */
+    @Deprecated
     public static Scheduler threadPoolForIO() {
         return executor(IO_EXECUTOR);
     }
+    
+    /**
+     * {@link Scheduler} intended for IO-bound work.
+     * 
    
+     * The implementation is backed by an {@link Executor} thread-pool that will grow as needed.
+     * 
    
+     * This can be used for asynchronously performing blocking IO.
+     * 
    
+     * Do not perform computational work on this scheduler. Use {@link #computation()} instead.
+     * 
+     * @return {@link ExecutorScheduler} for IO-bound work.
+     */
+    public static Scheduler io() {
+        return executor(IO_EXECUTOR);
+    }
 
     private static ScheduledExecutorService createComputationExecutor() {
         int cores = Runtime.getRuntime().availableProcessors();

From 2e53b6752b3a3ef0ac872c9cbbfa3e915d765646 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Mon, 6 Jan 2014 14:58:52 -0800
Subject: [PATCH 183/441] The test has to wait on each action independently.
 Reduced the size of the iterable because I think it was blowing through the
 stack.

---
 .../src/test/java/rx/ObserveOnTests.java      |  6 +++---
 .../rx/schedulers/AbstractSchedulerTests.java | 19 +++++++++++++++++--
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/ObserveOnTests.java b/rxjava-core/src/test/java/rx/ObserveOnTests.java
index 3f9e474787..72c1f1343d 100644
--- a/rxjava-core/src/test/java/rx/ObserveOnTests.java
+++ b/rxjava-core/src/test/java/rx/ObserveOnTests.java
@@ -35,7 +35,7 @@ public void testObserveOnWithNewThreadScheduler() {
         final AtomicInteger count = new AtomicInteger();
         final int _multiple = 99;
 
-        Observable.range(1, 100000).map(new Func1() {
+        Observable.range(1, 1000).map(new Func1() {
 
             @Override
             public Integer call(Integer t1) {
@@ -62,7 +62,7 @@ public void testObserveOnWithThreadPoolScheduler() {
         final AtomicInteger count = new AtomicInteger();
         final int _multiple = 99;
 
-        Observable.range(1, 100000).map(new Func1() {
+        Observable.range(1, 1000).map(new Func1() {
 
             @Override
             public Integer call(Integer t1) {
@@ -95,7 +95,7 @@ public void testObserveOnOrderingConcurrency() {
         final AtomicInteger count = new AtomicInteger();
         final int _multiple = 99;
 
-        Observable.range(1, 10000).map(new Func1() {
+        Observable.range(1, 1000).map(new Func1() {
 
             @Override
             public Integer call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index ddf4f959a6..07d430f625 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -205,16 +205,31 @@ public String call(String s) {
         assertTrue(strings.contains("names=>b-2"));
     }
 
+    /**
+     * The order of execution is nondeterministic.
+     * @throws InterruptedException
+     */
     @SuppressWarnings("rawtypes")
     @Test
     public final void testSequenceOfActions() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
 
-        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch latch = new CountDownLatch(2);
         final Action0 first = mock(Action0.class);
         final Action0 second = mock(Action0.class);
 
-        // make it wait until after the second is called
+        // make it wait until both the first and second are called
+        doAnswer(new Answer() {
+
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                try {
+                    return invocation.getMock();
+                } finally {
+                    latch.countDown();
+                }
+            }
+        }).when(first).call();
         doAnswer(new Answer() {
 
             @Override

From a18b8c1a572b7b9509b7a7fe1a5075ce93657771 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 6 Jan 2014 18:05:49 -0800
Subject: [PATCH 184/441] ToObservableIterable Recursion/Loop

- the ImmediateScheduler no longer schedules itself but uses a loop
- 10-20x faster to use a loop rather than schedule itself recursively
---
 .../OperationToObservableIterable.java        |  34 ++++-
 .../src/test/java/rx/ObserveOnTests.java      | 133 ------------------
 .../rx/operators/OperationObserveOnTest.java  | 104 ++++++++++++++
 .../OperationToObservableIterableTest.java    |  15 ++
 .../schedulers/SchedulerPerformanceTests.java |  26 ++--
 5 files changed, 162 insertions(+), 150 deletions(-)
 delete mode 100644 rxjava-core/src/test/java/rx/ObserveOnTests.java

diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
index 7fb5f0ec91..4518715908 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
@@ -19,6 +19,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
@@ -37,16 +38,20 @@
 public final class OperationToObservableIterable {
 
     public static  OnSubscribeFunc toObservableIterable(Iterable list, Scheduler scheduler) {
-        return new ToObservableIterable(list, scheduler);
+        if (scheduler instanceof ImmediateScheduler) {
+            return new ToObservableIterable(list);
+        } else {
+            return new ToObservableIterableScheduled(list, scheduler);
+        }
     }
 
     public static  OnSubscribeFunc toObservableIterable(Iterable list) {
-        return toObservableIterable(list, Schedulers.immediate());
+        return new ToObservableIterable(list);
     }
 
-    private static class ToObservableIterable implements OnSubscribeFunc {
+    private static class ToObservableIterableScheduled implements OnSubscribeFunc {
 
-        public ToObservableIterable(Iterable list, Scheduler scheduler) {
+        public ToObservableIterableScheduled(Iterable list, Scheduler scheduler) {
             this.iterable = list;
             this.scheduler = scheduler;
         }
@@ -74,4 +79,25 @@ public void call(Action0 self) {
             });
         }
     }
+
+    private static class ToObservableIterable implements OnSubscribeFunc {
+
+        public ToObservableIterable(Iterable list) {
+            this.iterable = list;
+        }
+
+        final Iterable iterable;
+
+        public Subscription onSubscribe(final Observer observer) {
+            try {
+                for (T t : iterable) {
+                    observer.onNext(t);
+                }
+                observer.onCompleted();
+            } catch (Exception e) {
+                observer.onError(e);
+            }
+            return Subscriptions.empty();
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/ObserveOnTests.java b/rxjava-core/src/test/java/rx/ObserveOnTests.java
deleted file mode 100644
index 72c1f1343d..0000000000
--- a/rxjava-core/src/test/java/rx/ObserveOnTests.java
+++ /dev/null
@@ -1,133 +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 org.junit.Assert.*;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.junit.Test;
-
-import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-
-public class ObserveOnTests {
-
-    /**
-     * Confirm that running on a NewThreadScheduler uses the same thread for the entire stream
-     */
-    @Test
-    public void testObserveOnWithNewThreadScheduler() {
-        final AtomicInteger count = new AtomicInteger();
-        final int _multiple = 99;
-
-        Observable.range(1, 1000).map(new Func1() {
-
-            @Override
-            public Integer call(Integer t1) {
-                return t1 * _multiple;
-            }
-
-        }).observeOn(Schedulers.newThread())
-                .toBlockingObservable().forEach(new Action1() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
-                        assertTrue(Thread.currentThread().getName().startsWith("RxNewThreadScheduler"));
-                    }
-
-                });
-    }
-
-    /**
-     * Confirm that running on a ThreadPoolScheduler allows multiple threads but is still ordered.
-     */
-    @Test
-    public void testObserveOnWithThreadPoolScheduler() {
-        final AtomicInteger count = new AtomicInteger();
-        final int _multiple = 99;
-
-        Observable.range(1, 1000).map(new Func1() {
-
-            @Override
-            public Integer call(Integer t1) {
-                return t1 * _multiple;
-            }
-
-        }).observeOn(Schedulers.threadPoolForComputation())
-                .toBlockingObservable().forEach(new Action1() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
-                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
-                    }
-
-                });
-    }
-
-    /**
-     * Attempts to confirm that when pauses exist between events, the ScheduledObserver
-     * does not lose or reorder any events since the scheduler will not block, but will
-     * be re-scheduled when it receives new events after each pause.
-     * 
-     * 
-     * This is non-deterministic in proving success, but if it ever fails (non-deterministically)
-     * it is a sign of potential issues as thread-races and scheduling should not affect output.
-     */
-    @Test
-    public void testObserveOnOrderingConcurrency() {
-        final AtomicInteger count = new AtomicInteger();
-        final int _multiple = 99;
-
-        Observable.range(1, 1000).map(new Func1() {
-
-            @Override
-            public Integer call(Integer t1) {
-                if (randomIntFrom0to100() > 98) {
-                    try {
-                        Thread.sleep(2);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
-                }
-                return t1 * _multiple;
-            }
-
-        }).observeOn(Schedulers.threadPoolForComputation())
-                .toBlockingObservable().forEach(new Action1() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
-                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
-                    }
-
-                });
-    }
-
-    private static int randomIntFrom0to100() {
-        // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
-        long x = System.nanoTime();
-        x ^= (x << 21);
-        x ^= (x >>> 35);
-        x ^= (x << 4);
-        return Math.abs((int) x % 100);
-    }
-
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
index 626d6409d7..dfc14750c8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
@@ -22,6 +22,7 @@
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -34,6 +35,7 @@
 import rx.schedulers.TestScheduler;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 
 public class OperationObserveOnTest {
 
@@ -210,6 +212,108 @@ public void observeSameOnMultipleSchedulers() {
         inOrder2.verify(observer2, times(1)).onCompleted();
         verify(observer2, never()).onError(any(Throwable.class));
         inOrder2.verifyNoMoreInteractions();
+    }
+    
+    /**
+     * Confirm that running on a NewThreadScheduler uses the same thread for the entire stream
+     */
+    @Test
+    public void testObserveOnWithNewThreadScheduler() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 100000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                return t1 * _multiple;
+            }
+
+        }).observeOn(Schedulers.newThread())
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxNewThreadScheduler"));
+                    }
+
+                });
+    }
+
+    /**
+     * Confirm that running on a ThreadPoolScheduler allows multiple threads but is still ordered.
+     */
+    @Test
+    public void testObserveOnWithThreadPoolScheduler() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 100000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                return t1 * _multiple;
+            }
+
+        }).observeOn(Schedulers.computation())
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                    }
+
+                });
+    }
+
+    /**
+     * Attempts to confirm that when pauses exist between events, the ScheduledObserver
+     * does not lose or reorder any events since the scheduler will not block, but will
+     * be re-scheduled when it receives new events after each pause.
+     * 
+     * 
+     * This is non-deterministic in proving success, but if it ever fails (non-deterministically)
+     * it is a sign of potential issues as thread-races and scheduling should not affect output.
+     */
+    @Test
+    public void testObserveOnOrderingConcurrency() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 10000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                if (randomIntFrom0to100() > 98) {
+                    try {
+                        Thread.sleep(2);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+                return t1 * _multiple;
+            }
+
+        }).observeOn(Schedulers.computation())
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                    }
+
+                });
+    }
 
+    private static int randomIntFrom0to100() {
+        // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
+        long x = System.nanoTime();
+        x ^= (x << 21);
+        x ^= (x >>> 35);
+        x ^= (x << 4);
+        return Math.abs((int) x % 100);
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
index 8d8be93dcb..16ad47f372 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
@@ -26,6 +26,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.schedulers.Schedulers;
 
 public class OperationToObservableIterableTest {
 
@@ -42,4 +43,18 @@ public void testIterable() {
         verify(aObserver, Mockito.never()).onError(any(Throwable.class));
         verify(aObserver, times(1)).onCompleted();
     }
+    
+    @Test
+    public void testIterableScheduled() {
+        Observable observable = Observable.create(toObservableIterable(Arrays. asList("one", "two", "three"), Schedulers.currentThread()));
+
+        @SuppressWarnings("unchecked")
+        Observer aObserver = mock(Observer.class);
+        observable.subscribe(aObserver);
+        verify(aObserver, times(1)).onNext("one");
+        verify(aObserver, times(1)).onNext("two");
+        verify(aObserver, times(1)).onNext("three");
+        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
+        verify(aObserver, times(1)).onCompleted();
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java b/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java
index 1f166dbfa6..986ef75c34 100644
--- a/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/SchedulerPerformanceTests.java
@@ -35,12 +35,12 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    //                    spt.singleResponse(Schedulers.immediate());
+                    spt.singleResponse(Schedulers.immediate());
                     //                    spt.singleResponse(Schedulers.currentThread());
                     //                    spt.singleResponse(Schedulers.threadPoolForComputation());
 
-                    spt.arrayResponse(Schedulers.immediate());
-                    //                    spt.arrayResponse(Schedulers.currentThread());
+                    //                    spt.arrayResponse(Schedulers.immediate());
+                    //                                        spt.arrayResponse(Schedulers.currentThread());
                     //                    spt.arrayResponse(Schedulers.threadPoolForComputation());
                 }
             });
@@ -92,11 +92,11 @@ public long baseline() {
      * 
      * --- Schedulers.immediate() ---
      * 
-     * Run: 10 - 4,113,672 ops/sec
-     * Run: 11 - 4,068,351 ops/sec
-     * Run: 12 - 4,070,318 ops/sec
-     * Run: 13 - 4,161,793 ops/sec
-     * Run: 14 - 4,156,725 ops/sec
+     * Run: 10 - 14,973,870 ops/sec
+     * Run: 11 - 15,345,142 ops/sec
+     * Run: 12 - 14,962,533 ops/sec
+     * Run: 13 - 14,793,030 ops/sec
+     * Run: 14 - 15,177,685 ops/sec
      * 
      * --- Schedulers.currentThread() ---
      * 
@@ -127,11 +127,11 @@ public long singleResponse(Scheduler scheduler) {
      * 
      * --- Schedulers.immediate() ---
      * 
-     * Run: 0 - 1,849,947 ops/sec
-     * Run: 1 - 2,076,067 ops/sec
-     * Run: 2 - 2,114,688 ops/sec
-     * Run: 3 - 2,114,301 ops/sec
-     * Run: 4 - 2,102,543 ops/sec
+     * Run: 10 - 9,805,017 ops/sec
+     * Run: 11 - 9,880,427 ops/sec
+     * Run: 12 - 9,615,809 ops/sec
+     * Run: 13 - 10,920,297 ops/sec
+     * Run: 14 - 10,822,721 ops/sec
      * 
      * --- Schedulers.currentThread() ---
      * 

From 8052b3a5f272ea85b31ebcfaca4b575788d538d3 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 6 Jan 2014 18:53:56 -0800
Subject: [PATCH 185/441] 0.16.0-SNAPSHOT

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 92fc8fd0ca..baf14210e5 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.15.2-SNAPSHOT
+version=0.16.0-SNAPSHOT

From 8b0f3b007a8ace9c96f1f42c88c9aa84a81d9a4d Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Fri, 3 Jan 2014 17:27:58 +0800
Subject: [PATCH 186/441] Implemented the rest 'merge' overloads

---
 rxjava-core/src/main/java/rx/Observable.java  | 170 ++++++++++++--
 .../java/rx/operators/OperationMerge.java     | 209 +++++++-----------
 .../java/rx/operators/OperationMergeTest.java |  22 +-
 3 files changed, 238 insertions(+), 163 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 92fb348879..40264c6c4b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1257,10 +1257,8 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2));
     }
 
     /**
@@ -1280,10 +1278,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3));
     }
 
     /**
@@ -1304,10 +1300,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4));
     }
 
     /**
@@ -1329,10 +1323,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4, t5));
     }
 
     /**
@@ -1355,10 +1347,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4, t5, t6));
     }
 
     /**
@@ -1382,10 +1372,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4, t5, t6, t7));
     }
 
     /**
@@ -1410,10 +1398,8 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
 
     /**
@@ -1439,10 +1425,148 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    }
+
+    /**
+     * Flattens a sequence of Observables emitted by an Observable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * 
    
+     * 
+     * 
    
+     * 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
+     * @param maxConcurrent the maximum number of Observables being subscribed to concurrently
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables emitted by the
+     *         {@code source} Observable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable> source, int maxConcurrent) {
+        return create(OperationMerge.merge(source, maxConcurrent));
+    }
+
+    /**
+     * Flattens an Observable Iterable 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 sequences the Observable Iterable
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Iterable> sequences) {
+        return merge(from(sequences));
+    }
+
+    /**
+     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * 
    
+     * 
+     * 
    
+     * You can combine the items emitted by multiple Observables so that they
+     * act like a single Observable, by using the {@code merge} method.
+     * 
+     * @param sequences the Observable Iterable
+     * @param maxConcurrent the maximum number of Observables being subscribed to concurrently
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Iterable> sequences, int maxConcurrent) {
+        return merge(from(sequences), maxConcurrent);
+    }
+
+    /**
+     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * 
    
+     * 
+     * 
    
+     * You can combine the items emitted by multiple Observables so that they
+     * act like a single Observable, by using the {@code merge} method.
+     * 
+     * @param sequences the Observable Iterable
+     * @param maxConcurrent the maximum number of Observables being subscribed to concurrently
+     * @param scheduler the scheduler to traversal the Observable array on
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Iterable> sequences, int maxConcurrent, Scheduler scheduler) {
+        return merge(from(sequences, scheduler), maxConcurrent);
+    }
+
+    /**
+     * Flattens an Observable Iterable 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 sequences the Observable Iterable
+     * @param scheduler the scheduler to traversal the Observable array on
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Iterable> sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
+    }
+
+    /**
+     * Flattens an Observable array 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 sequences the Observable array
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the array
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable[] sequences) {
+        return merge(from(sequences));
+    }
+
+    /**
+     * Flattens an Observable array 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 sequences the Observable array
+     * @param scheduler the scheduler to traversal the Observable array on
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the array
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable[] sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMerge.java b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
index 12619e9176..782c2ae6dd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
@@ -15,9 +15,7 @@
  */
 package rx.operators;
 
-import java.util.Arrays;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.LinkedList;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
@@ -44,51 +42,22 @@ public final class OperationMerge {
      * @see Observable.Merge(TSource) Method (IObservable(TSource)[])
      */
     public static  OnSubscribeFunc merge(final Observable> o) {
-        // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take rather than 1 handing both, which is not thread-safe.
+        return merge(o, Integer.MAX_VALUE);
+    }
+
+    public static  OnSubscribeFunc merge(final Observable> o, final int maxConcurrent) {
+        if (maxConcurrent <= 0) {
+            throw new IllegalArgumentException("maxConcurrent must be positive");
+        }
         return new OnSubscribeFunc() {
 
             @Override
             public Subscription onSubscribe(Observer observer) {
-                return new MergeObservable(o).onSubscribe(observer);
+                return new MergeObservable(o, maxConcurrent).onSubscribe(observer);
             }
         };
     }
 
-    public static  OnSubscribeFunc merge(final Observable... sequences) {
-        return merge(Arrays.asList(sequences));
-    }
-
-    public static  OnSubscribeFunc merge(final Iterable> sequences) {
-        return merge(Observable.create(new OnSubscribeFunc>() {
-
-            private volatile boolean unsubscribed = false;
-
-            @Override
-            public Subscription onSubscribe(Observer> observer) {
-                for (Observable o : sequences) {
-                    if (!unsubscribed) {
-                        observer.onNext(o);
-                    } else {
-                        // break out of the loop if we are unsubscribed
-                        break;
-                    }
-                }
-                if (!unsubscribed) {
-                    observer.onCompleted();
-                }
-
-                return new Subscription() {
-
-                    @Override
-                    public void unsubscribe() {
-                        unsubscribed = true;
-                    }
-
-                };
-            }
-        }));
-    }
-
     /**
      * This class is NOT thread-safe if invoked and referenced multiple times. In other words, don't subscribe to it multiple times from different threads.
      * 
    
@@ -102,18 +71,22 @@ public void unsubscribe() {
      */
     private static final class MergeObservable implements OnSubscribeFunc {
         private final Observable> sequences;
-        private final MergeSubscription ourSubscription = new MergeSubscription();
-        private AtomicBoolean stopped = new AtomicBoolean(false);
+        private final CompositeSubscription ourSubscription = new CompositeSubscription();
         private volatile boolean parentCompleted = false;
-        private final ConcurrentHashMap childObservers = new ConcurrentHashMap();
-        private final ConcurrentHashMap childSubscriptions = new ConcurrentHashMap();
+        private final LinkedList> pendingObservables = new LinkedList>();
+        private volatile int activeObservableCount = 0;
+        private final int maxConcurrent;
+        /**
+         * Protect both pendingObservables and activeObservableCount from concurrent accesses.
+         */
+        private final Object gate = new Object();
 
-        private MergeObservable(Observable> sequences) {
+        private MergeObservable(Observable> sequences, int maxConcurrent) {
             this.sequences = sequences;
+            this.maxConcurrent = maxConcurrent;
         }
 
         public Subscription onSubscribe(Observer actualObserver) {
-            CompositeSubscription completeSubscription = new CompositeSubscription();
 
             /**
              * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting.
@@ -123,44 +96,16 @@ public Subscription onSubscribe(Observer actualObserver) {
              * Bug report: https://github.com/Netflix/RxJava/issues/200
              */
             SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription);
-            completeSubscription.add(subscription);
-            SynchronizedObserver synchronizedObserver = new SynchronizedObserver(actualObserver, subscription);
+            SynchronizedObserver synchronizedObserver = new SynchronizedObserver(
+                    new SafeObserver(subscription, actualObserver), // Create a SafeObserver as SynchronizedObserver does not automatically unsubscribe
+                    subscription);
 
             /**
              * Subscribe to the parent Observable to get to the children Observables
              */
-            completeSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver)));
+            ourSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver)));
 
-            /* return our subscription to allow unsubscribing */
-            return completeSubscription;
-        }
-
-        /**
-         * Manage the internal subscription with a thread-safe means of stopping/unsubscribing so we don't unsubscribe twice.
-         * 
    
-         * Also has the stop() method returning a boolean so callers know if their thread "won" and should perform further actions.
-         */
-        private class MergeSubscription implements Subscription {
-
-            @Override
-            public void unsubscribe() {
-                stop();
-            }
-
-            public boolean stop() {
-                // try setting to false unless another thread beat us
-                boolean didSet = stopped.compareAndSet(false, true);
-                if (didSet) {
-                    // this thread won the race to stop, so unsubscribe from the actualSubscription
-                    for (Subscription _s : childSubscriptions.values()) {
-                        _s.unsubscribe();
-                    }
-                    return true;
-                } else {
-                    // another thread beat us
-                    return false;
-                }
-            }
+            return subscription;
         }
 
         /**
@@ -169,36 +114,34 @@ public boolean stop() {
          * @param 
          */
         private class ParentObserver implements Observer> {
-            private final Observer actualObserver;
+            private final SynchronizedObserver synchronizedObserver;
 
-            public ParentObserver(Observer actualObserver) {
-                this.actualObserver = actualObserver;
+            public ParentObserver(SynchronizedObserver synchronizedObserver) {
+                this.synchronizedObserver = synchronizedObserver;
             }
 
             @Override
             public void onCompleted() {
                 parentCompleted = true;
+                if (ourSubscription.isUnsubscribed()) {
+                    return;
+                }
                 // this *can* occur before the children are done, so if it does we won't send onCompleted
                 // but will let the child worry about it
                 // if however this completes and there are no children processing, then we will send onCompleted
-
-                if (childObservers.size() == 0) {
-                    if (!stopped.get()) {
-                        if (ourSubscription.stop()) {
-                            actualObserver.onCompleted();
-                        }
-                    }
+                if (isStopped()) {
+                    synchronizedObserver.onCompleted();
                 }
             }
 
             @Override
             public void onError(Throwable e) {
-                actualObserver.onError(e);
+                synchronizedObserver.onError(e);
             }
 
             @Override
             public void onNext(Observable childObservable) {
-                if (stopped.get()) {
+                if (ourSubscription.isUnsubscribed()) {
                     // we won't act on any further items
                     return;
                 }
@@ -207,17 +150,20 @@ public void onNext(Observable childObservable) {
                     throw new IllegalArgumentException("Observable can not be null.");
                 }
 
-                /**
-                 * For each child Observable we receive we'll subscribe with a separate Observer
-                 * that will each then forward their sequences to the actualObserver.
-                 * 
    
-                 * We use separate child Observers for each sequence to simplify the onComplete/onError handling so each sequence has its own lifecycle.
-                 */
-                ChildObserver _w = new ChildObserver(actualObserver);
-                childObservers.put(_w, _w);
-                Subscription _subscription = childObservable.subscribe(_w);
-                // remember this Observer and the subscription from it
-                childSubscriptions.put(_w, _subscription);
+                Observable observable = null;
+                synchronized(gate) {
+                    if(activeObservableCount >= maxConcurrent) {
+                        pendingObservables.add(childObservable);
+                    }
+                    else {
+                        observable = childObservable;
+                        activeObservableCount++;
+                    }
+                }
+                if (observable != null) {
+                    ourSubscription.add(observable.subscribe(new ChildObserver(
+                            synchronizedObserver)));
+                }
             }
         }
 
@@ -227,47 +173,58 @@ public void onNext(Observable childObservable) {
          */
         private class ChildObserver implements Observer {
 
-            private final Observer actualObserver;
+            private final SynchronizedObserver synchronizedObserver;
 
-            public ChildObserver(Observer actualObserver) {
-                this.actualObserver = actualObserver;
+            public ChildObserver(SynchronizedObserver synchronizedObserver) {
+                this.synchronizedObserver = synchronizedObserver;
             }
 
             @Override
             public void onCompleted() {
-                // remove self from map of Observers
-                childObservers.remove(this);
-                // if there are now 0 Observers left, so if the parent is also completed we send the onComplete to the actualObserver
-                // if the parent is not complete that means there is another sequence (and child Observer) to come
-                if (!stopped.get()) {
-                    if (childObservers.size() == 0 && parentCompleted) {
-                        if (ourSubscription.stop()) {
-                            // this thread 'won' the race to unsubscribe/stop so let's send onCompleted
-                            actualObserver.onCompleted();
-                        }
+                if (ourSubscription.isUnsubscribed()) {
+                    return;
+                }
+
+                Observable childObservable = null;
+                // Try to fetch a pending observable
+                synchronized (gate) {
+                    childObservable = pendingObservables.poll();
+                    if(childObservable == null) {
+                        // There is no pending observable, decrease activeObservableCount.
+                        activeObservableCount--;
+                    }
+                    else {
+                        // Fetch an observable successfully.
+                        // We will subscribe(this) at once. So don't change activeObservableCount.
+                    }
+                }
+                if (childObservable != null) {
+                    ourSubscription.add(childObservable.subscribe(this));
+                } else {
+                    // No pending observable. Need to check if it's necessary to emit an onCompleted
+                    if (isStopped()) {
+                        synchronizedObserver.onCompleted();
                     }
                 }
             }
 
             @Override
             public void onError(Throwable e) {
-                if (!stopped.get()) {
-                    if (ourSubscription.stop()) {
-                        // this thread 'won' the race to unsubscribe/stop so let's send the error
-                        actualObserver.onError(e);
-                    }
-                }
+                synchronizedObserver.onError(e);
             }
 
             @Override
             public void onNext(T args) {
-                // in case the Observable is poorly behaved and doesn't listen to the unsubscribe request
-                // we'll ignore anything that comes in after we've unsubscribed
-                if (!stopped.get()) {
-                    actualObserver.onNext(args);
-                }
+                synchronizedObserver.onNext(args);
             }
 
         }
+
+        private boolean isStopped() {
+            synchronized (gate) {
+                return parentCompleted && activeObservableCount == 0
+                        && pendingObservables.size() == 0;
+            }
+        }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
index 311a838691..4778d8038a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
@@ -74,7 +74,7 @@ public void unsubscribe() {
             }
 
         });
-        Observable m = Observable.create(merge(observableOfObservables));
+        Observable m = Observable.merge(observableOfObservables);
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -87,8 +87,7 @@ public void testMergeArray() {
         final Observable o1 = Observable.create(new TestSynchronousObservable());
         final Observable o2 = Observable.create(new TestSynchronousObservable());
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(o1, o2));
+        Observable m = Observable.merge(o1, o2);
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -104,7 +103,7 @@ public void testMergeList() {
         listOfObservables.add(o1);
         listOfObservables.add(o2);
 
-        Observable m = Observable.create(merge(listOfObservables));
+        Observable m = Observable.merge(listOfObservables);
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -117,8 +116,7 @@ public void testUnSubscribe() {
         TestObservable tA = new TestObservable();
         TestObservable tB = new TestObservable();
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(Observable.create(tA), Observable.create(tB)));
+        Observable m = Observable.merge(Observable.create(tA), Observable.create(tB));
         Subscription s = m.subscribe(stringObserver);
 
         tA.sendOnNext("Aone");
@@ -210,8 +208,7 @@ public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o1 = new TestASynchronousObservable();
         final TestASynchronousObservable o2 = new TestASynchronousObservable();
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(Observable.create(o1), Observable.create(o2)));
+        Observable m = Observable.merge(Observable.create(o1), Observable.create(o2));
         m.subscribe(stringObserver);
 
         try {
@@ -237,8 +234,7 @@ public void testSynchronizationOfMultipleSequences() throws Throwable {
         final AtomicInteger concurrentCounter = new AtomicInteger();
         final AtomicInteger totalCounter = new AtomicInteger();
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(Observable.create(o1), Observable.create(o2)));
+        Observable m = Observable.merge(Observable.create(o1), Observable.create(o2));
         m.subscribe(new Observer() {
 
             @Override
@@ -308,8 +304,7 @@ public void testError1() {
         final Observable o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
         final Observable o2 = Observable.create(new TestErrorObservable("one", "two", "three")); // we expect to lose all of these since o1 is done first and fails
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(o1, o2));
+        Observable m = Observable.merge(o1, o2);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));
@@ -333,8 +328,7 @@ public void testError2() {
         final Observable o3 = Observable.create(new TestErrorObservable("seven", "eight", null));// we expect to lose all of these since o2 is done first and fails
         final Observable o4 = Observable.create(new TestErrorObservable("nine"));// we expect to lose all of these since o2 is done first and fails
 
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(merge(o1, o2, o3, o4));
+        Observable m = Observable.merge(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));

From 7526eb73c8374bb98413d3c1d4db9e45391583a8 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Sat, 4 Jan 2014 00:32:06 +0800
Subject: [PATCH 187/441] Added unit tests

---
 .../java/rx/operators/OperationMergeTest.java | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
index 4778d8038a..becf17d803 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
@@ -21,6 +21,8 @@
 import static rx.operators.OperationMerge.*;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -35,6 +37,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
@@ -465,4 +468,85 @@ public void unsubscribe() {
             };
         }
     }
+
+    @Test
+    public void testWhenMaxConcurrentIsOne() {
+        for (int i = 0; i < 100; i++) {
+            List> os = new ArrayList>();
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+
+            List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five");
+            Iterator iter = Observable.merge(os, 1).toBlockingObservable().toIterable().iterator();
+            List actual = new ArrayList();
+            while(iter.hasNext()) {
+                actual.add(iter.next());
+            }
+            assertEquals(expected, actual);
+        }
+    }
+
+    @Test
+    public void testMaxConcurrent() {
+        for (int times = 0; times < 100; times++) {
+            int observableCount = 100;
+            // Test maxConcurrent from 2 to 12
+            int maxConcurrent = 2 + (times % 10);
+            AtomicInteger subscriptionCount = new AtomicInteger(0);
+
+            List> os = new ArrayList>();
+            List scos = new ArrayList();
+            for (int i = 0; i < observableCount; i++) {
+                SubscriptionCheckObservable sco = new SubscriptionCheckObservable(
+                        subscriptionCount, maxConcurrent);
+                scos.add(sco);
+                os.add(Observable.create(sco).subscribeOn(
+                        Schedulers.threadPoolForComputation()));
+            }
+
+            Iterator iter = Observable.merge(os, maxConcurrent)
+                    .toBlockingObservable().toIterable().iterator();
+            List actual = new ArrayList();
+            while (iter.hasNext()) {
+                actual.add(iter.next());
+            }
+            assertEquals(5 * observableCount, actual.size());
+            for (SubscriptionCheckObservable sco : scos) {
+                assertFalse(sco.failed);
+            }
+        }
+    }
+
+    private static class SubscriptionCheckObservable implements
+            Observable.OnSubscribeFunc {
+
+        private final AtomicInteger subscriptionCount;
+        private final int maxConcurrent;
+        volatile boolean failed = false;
+
+        SubscriptionCheckObservable(AtomicInteger subscriptionCount,
+                int maxConcurrent) {
+            this.subscriptionCount = subscriptionCount;
+            this.maxConcurrent = maxConcurrent;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            if (subscriptionCount.incrementAndGet() > maxConcurrent) {
+                failed = true;
+            }
+            t1.onNext("one");
+            t1.onNext("two");
+            t1.onNext("three");
+            t1.onNext("four");
+            t1.onNext("five");
+            // We could not decrement subscriptionCount in the unsubscribe method
+            // as "unsubscribe" is not guaranteed to be called before the next "subscribe".
+            subscriptionCount.decrementAndGet();
+            t1.onCompleted();
+            return Subscriptions.empty();
+        }
+
+    }
 }

From 9d53cb6963bbaad2b24bc0755c6d6b8e3e2080e1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 7 Jan 2014 12:44:32 -0800
Subject: [PATCH 188/441] 0.16.1-SNAPSHOT

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index baf14210e5..d7a4f05753 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.16.0-SNAPSHOT
+version=0.16.1-SNAPSHOT

From 72f043e01358ac853ad31b928edde99c50a892b4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 7 Jan 2014 12:45:39 -0800
Subject: [PATCH 189/441] Version 0.16.0

---
 CHANGES.md | 86 +++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 78 insertions(+), 8 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 8e30cb39fd..b5e8b36935 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,82 @@
 # RxJava Releases #
 
+### Version 0.16.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.16.0%22)) ###
+
+
+This is a significant release with the following changes:
+
+- Refactor of Subjects and Subscriptions to non-blocking implementations 
+- Many bug fixes, new operators and behavior changes to match Rx.Net. 
+- Deprecation of some operators due to renaming or eliminating duplicates 
+- The `rx.concurrency` package has been renamed to `rx.schedulers`. Existing classes still remain in `rx.concurrency` but are deprecated. Use of `rx.concurrency` should be migrated to `rx.schedulers` as these deprecated classes will be removed in a future release. 
+- Breaking changes to Scala bindings. See [Release Notes](https://github.com/Netflix/RxJava/blob/master/language-adaptors/rxjava-scala/ReleaseNotes.md) for details.
+- New modules: rxjava-string, rxjava-async-util and rxjava-computation-expressions for operators deemed not applicable to the core library. 
+
+---
+
+* [Pull 516](https://github.com/Netflix/RxJava/pull/516) rxjava-string module with StringObservable
+* [Pull 533](https://github.com/Netflix/RxJava/pull/533) Operator: ToAsync
+* [Pull 535](https://github.com/Netflix/RxJava/pull/535) Fix compilation errors due to referencing the Android support library directly
+* [Pull 545](https://github.com/Netflix/RxJava/pull/545) Fixed Zip issue with infinite streams
+* [Pull 539](https://github.com/Netflix/RxJava/pull/539) Zipping a finite and an infinite Observable
+* [Pull 541](https://github.com/Netflix/RxJava/pull/541) Operator: SkipUntil
+* [Pull 537](https://github.com/Netflix/RxJava/pull/537) Add scala adapters for doOnEach operator
+* [Pull 560](https://github.com/Netflix/RxJava/pull/560) Add type variances for doOnEach actions
+* [Pull 562](https://github.com/Netflix/RxJava/pull/562) Scala Adaptor Improvements
+* [Pull 563](https://github.com/Netflix/RxJava/pull/563) Operator: GroupByUntil
+* [Pull 561](https://github.com/Netflix/RxJava/pull/561) Revised Approach to Creating Observables in Scala
+* [Pull 565](https://github.com/Netflix/RxJava/pull/565) Operator: GroupJoin v2
+* [Pull 567](https://github.com/Netflix/RxJava/pull/567) Operator: Timestamp with Scheduler
+* [Pull 568](https://github.com/Netflix/RxJava/pull/568) Use lock free strategy for several Subscription implementations
+* [Pull 571](https://github.com/Netflix/RxJava/pull/571) Operator: Sample with Observable v2
+* [Pull 572](https://github.com/Netflix/RxJava/pull/572) Multiple Subscriptions to ObserveOn
+* [Pull 573](https://github.com/Netflix/RxJava/pull/573) Removed Opening and Closing historical artifacts
+* [Pull 575](https://github.com/Netflix/RxJava/pull/575) Operator: SequenceEqual reimplementation
+* [Pull 587](https://github.com/Netflix/RxJava/pull/587) Operator: LongCount
+* [Pull 586](https://github.com/Netflix/RxJava/pull/586) Fix Concat to allow multiple observers
+* [Pull 598](https://github.com/Netflix/RxJava/pull/598) New Scala Bindings
+* [Pull 596](https://github.com/Netflix/RxJava/pull/596) Fix for buffer not stopping when unsubscribed
+* [Pull 576](https://github.com/Netflix/RxJava/pull/576) Operators: Timer and Delay
+* [Pull 593](https://github.com/Netflix/RxJava/pull/593) Lock-free subscriptions
+* [Pull 599](https://github.com/Netflix/RxJava/pull/599) Refactor rx.concurrency to rx.schedulers
+* [Pull 600](https://github.com/Netflix/RxJava/pull/600) BugFix: Replay Subject
+* [Pull 594](https://github.com/Netflix/RxJava/pull/594) Operator: Start
+* [Pull 604](https://github.com/Netflix/RxJava/pull/604) StringObservable.join
+* [Pull 609](https://github.com/Netflix/RxJava/pull/609) Operation: Timer
+* [Pull 612](https://github.com/Netflix/RxJava/pull/612) Operation: Replay (overloads)
+* [Pull 628](https://github.com/Netflix/RxJava/pull/628) BugFix: MergeDelayError Synchronization
+* [Pull 602](https://github.com/Netflix/RxJava/pull/602) BugFix: ObserveOn Subscription leak
+* [Pull 631](https://github.com/Netflix/RxJava/pull/631) Make NewThreadScheduler create Daemon threads
+* [Pull 651](https://github.com/Netflix/RxJava/pull/651) Subjects Refactor - Non-Blocking, Common Abstraction, Performance
+* [Pull 661](https://github.com/Netflix/RxJava/pull/661) Subscriptions Rewrite
+* [Pull 520](https://github.com/Netflix/RxJava/pull/520) BugFix: blocking/non-blocking `first`
+* [Pull 621](https://github.com/Netflix/RxJava/pull/621) Scala: SerialSubscription & From
+* [Pull 626](https://github.com/Netflix/RxJava/pull/626) BO.Latest, fixed: BO.next, BO.mostRecent, BO.toIterable
+* [Pull 633](https://github.com/Netflix/RxJava/pull/633) BugFix: null in toList operator
+* [Pull 635](https://github.com/Netflix/RxJava/pull/635) Conditional Operators
+* [Pull 638](https://github.com/Netflix/RxJava/pull/638) Operations: DelaySubscription, TakeLast w/ time, TakeLastBuffer
+* [Pull 659](https://github.com/Netflix/RxJava/pull/659) Missing fixes from the subject rewrite
+* [Pull 688](https://github.com/Netflix/RxJava/pull/688) Fix SafeObserver handling of onComplete errors
+* [Pull 690](https://github.com/Netflix/RxJava/pull/690) Fixed Scala bindings
+* [Pull 693](https://github.com/Netflix/RxJava/pull/693) Kotlin M6.2
+* [Pull 689](https://github.com/Netflix/RxJava/pull/689) Removed ObserverBase
+* [Pull 664](https://github.com/Netflix/RxJava/pull/664) Operation: AsObservable
+* [Pull 697](https://github.com/Netflix/RxJava/pull/697) Operations: Skip, SkipLast, Take with time
+* [Pull 698](https://github.com/Netflix/RxJava/pull/698) Operations: Average, Sum
+* [Pull 699](https://github.com/Netflix/RxJava/pull/699) Operation: Repeat
+* [Pull 701](https://github.com/Netflix/RxJava/pull/701) Operation: Collect
+* [Pull 707](https://github.com/Netflix/RxJava/pull/707) Module: rxjava-async-util
+* [Pull 708](https://github.com/Netflix/RxJava/pull/708) BugFix: combineLatest
+* [Pull 712](https://github.com/Netflix/RxJava/pull/712) Fix Scheduler Memory Leaks
+* [Pull 714](https://github.com/Netflix/RxJava/pull/714) Module: rxjava-computation-expressions
+* [Pull 715](https://github.com/Netflix/RxJava/pull/715) Add missing type hint to clojure example
+* [Pull 717](https://github.com/Netflix/RxJava/pull/717) Scala: Added ConnectableObservable
+* [Pull 723](https://github.com/Netflix/RxJava/pull/723) Deprecate multiple arity ‘from’
+* [Pull 724](https://github.com/Netflix/RxJava/pull/724) Revert use of CurrentThreadScheduler for Observable.from
+* [Pull 725](https://github.com/Netflix/RxJava/pull/725) Simpler computation/io naming for Schedulers
+* [Pull 727](https://github.com/Netflix/RxJava/pull/727) ImmediateScheduler optimization for toObservableIterable
+
+
 ### Version 0.15.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.15.1%22)) ###
 
 This release should be additive functionality and bug fixes.
@@ -445,11 +522,4 @@ Also [removed](https://github.com/Netflix/RxJava/issues/173) were the `Observabl
 ### Version 0.5.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.5.1%22)) ###
 
 * variety of code cleanup commits
-* [Pull 132](https://github.com/Netflix/RxJava/pull/132) Broke rxjava-examples module into each language-adaptor module
-* [Issue 118](https://github.com/Netflix/RxJava/issues/118) & [Issue 119](https://github.com/Netflix/Hystrix/issues/119) Cleaned up Javadocs still referencing internal Netflix paths
-* Javadoc and README changes
-
-### Version 0.5.0  ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.5.0%22)) ###
-
-* Initial open source release 
-* See [Netflix Tech Blog](http://techblog.netflix.com/2013/02/rxjava-netflix-api.html) for introduction
+* [Pull 132](https://github.com/Netflix/RxJava/pull/132) Broke rxjava-examples mo

From 8e6bef3fc36d3f9544d8530e094a1031458aa50b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 8 Jan 2014 22:32:20 -0800
Subject: [PATCH 190/441] Improve Error Handling and Stacktraces
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The stacktraces were a mess when onError failed or was not implemented and unsubscribe also failed.
That is a far edge case and means code is broken and breaking the Rx contracts … but that’s just when we need clear stacktraces.
The CompositeException and SafeObserver class now do a dance and wire together a causal chain to provide a stacktrace that can identity all the points of error.
Also standardized and simplified the RxJavaPlugin.onErrorHandler while working in the vicinity.

This came about after I was asked to help debug a problem and couldn’t do it by looking at the thrown exception, I had to use a debugger and step through.
---
 rxjava-core/src/main/java/rx/Observable.java  |  14 -
 .../main/java/rx/operators/SafeObserver.java  |  34 ++-
 .../java/rx/plugins/RxJavaErrorHandler.java   |   2 +
 .../main/java/rx/plugins/RxJavaPlugins.java   |  15 +-
 .../main/java/rx/util/CompositeException.java |  66 +++-
 .../java/rx/operators/SafeObserverTest.java   | 285 +++++++++++++++++-
 .../java/rx/plugins/RxJavaPluginsTest.java    |  74 ++++-
 7 files changed, 433 insertions(+), 57 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 92fb348879..2ac2fb7b5d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -334,7 +334,6 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                handleError(e);
                 throw new OnErrorNotImplementedException(e);
             }
 
@@ -373,7 +372,6 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                handleError(e);
                 throw new OnErrorNotImplementedException(e);
             }
 
@@ -430,7 +428,6 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                handleError(e);
                 onError.call(e);
             }
 
@@ -491,7 +488,6 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                handleError(e);
                 onError.call(e);
             }
 
@@ -561,16 +557,6 @@ public  Observable multicast(
             final Func1, ? extends Observable> selector) {
         return OperationMulticast.multicast(this, subjectFactory, selector);
     }
-    /**
-     * 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}.
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 4768fb8653..965bc68963 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -114,10 +114,11 @@ public void onNext(T args) {
      */
     protected void _onError(Throwable e) {
         try {
+            RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
             actual.onError(e);
         } catch (Throwable e2) {
             if (e2 instanceof OnErrorNotImplementedException) {
-                /**
+                /*
                  * onError isn't implemented so throw
                  * 
                  * https://github.com/Netflix/RxJava/issues/198
@@ -128,19 +129,36 @@ protected void _onError(Throwable e) {
                  * to rethrow the exception on the thread that the message comes out from the observable sequence.
                  * The OnCompleted behavior in this case is to do nothing."
                  */
+                try {
+                    subscription.unsubscribe();
+                } catch (Throwable unsubscribeException) {
+                    RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    throw new RuntimeException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException)));
+                }
                 throw (OnErrorNotImplementedException) e2;
             } else {
-                // if the onError itself fails then pass to the plugin
-                // see https://github.com/Netflix/RxJava/issues/216 for further discussion
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                /*
+                 * throw since the Rx contract is broken if onError failed
+                 * 
+                 * https://github.com/Netflix/RxJava/issues/198
+                 */
                 RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
-                // and throw exception despite that not being proper for Rx
-                // https://github.com/Netflix/RxJava/issues/198
+                try {
+                    subscription.unsubscribe();
+                } catch (Throwable unsubscribeException) {
+                    RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    throw new RuntimeException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
+                }
+
                 throw new RuntimeException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
             }
-        } finally {
-            // auto-unsubscribe
+        }
+        // if we did not throw about we will unsubscribe here, if onError failed then unsubscribe happens in the catch
+        try {
             subscription.unsubscribe();
+        } catch (RuntimeException unsubscribeException) {
+            RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+            throw unsubscribeException;
         }
     }
 
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaErrorHandler.java b/rxjava-core/src/main/java/rx/plugins/RxJavaErrorHandler.java
index 8b621bb651..f97754a05b 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -30,6 +30,8 @@ public abstract class RxJavaErrorHandler {
 
     /**
      * Receives all Exceptions from an {@link Observable} passed to {@link Observer#onError(Throwable)}.
+     * 
    
+     * This should NEVER throw an Exception. Make sure to try/catch(Throwable) all code inside this method implementation.
      * 
      * @param e
      *            Exception
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
index 2eb806dd6b..5ca9a81420 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -32,12 +32,17 @@ public class RxJavaPlugins {
     private final AtomicReference errorHandler = new AtomicReference();
     private final AtomicReference observableExecutionHook = new AtomicReference();
 
+    public static RxJavaPlugins getInstance() {
+        return INSTANCE;
+    }
+
     /* package accessible for unit tests */RxJavaPlugins() {
 
     }
-
-    public static RxJavaPlugins getInstance() {
-        return INSTANCE;
+    
+    /* package accessible for ujnit tests */ void reset() {
+        INSTANCE.errorHandler.set(null);
+        INSTANCE.observableExecutionHook.set(null);
     }
 
     /**
@@ -74,7 +79,7 @@ public RxJavaErrorHandler getErrorHandler() {
      */
     public void registerErrorHandler(RxJavaErrorHandler impl) {
         if (!errorHandler.compareAndSet(null, impl)) {
-            throw new IllegalStateException("Another strategy was already registered.");
+            throw new IllegalStateException("Another strategy was already registered: " + errorHandler.get());
         }
     }
 
@@ -112,7 +117,7 @@ public RxJavaObservableExecutionHook getObservableExecutionHook() {
      */
     public void registerObservableExecutionHook(RxJavaObservableExecutionHook impl) {
         if (!observableExecutionHook.compareAndSet(null, impl)) {
-            throw new IllegalStateException("Another strategy was already registered.");
+            throw new IllegalStateException("Another strategy was already registered: " + observableExecutionHook.get());
         }
     }
 
diff --git a/rxjava-core/src/main/java/rx/util/CompositeException.java b/rxjava-core/src/main/java/rx/util/CompositeException.java
index b233a9f90b..c8534c9c11 100644
--- a/rxjava-core/src/main/java/rx/util/CompositeException.java
+++ b/rxjava-core/src/main/java/rx/util/CompositeException.java
@@ -25,29 +25,26 @@
  * 
    
  * The getMessage() will return a concatenation of the composite exceptions.
  */
-public class CompositeException extends RuntimeException {
+public final class CompositeException extends RuntimeException {
 
     private static final long serialVersionUID = 3026362227162912146L;
 
     private final List exceptions;
     private final String message;
+    private final Throwable cause;
 
     public CompositeException(String messagePrefix, Collection errors) {
-        StringBuilder _message = new StringBuilder();
-        if (messagePrefix != null) {
-            _message.append(messagePrefix).append(" => ");
-        }
-
         List _exceptions = new ArrayList();
+        CompositeExceptionCausalChain _cause = new CompositeExceptionCausalChain();
+        int count = 0;
         for (Throwable e : errors) {
+            count++;
+            attachCallingThreadStack(_cause, e);
             _exceptions.add(e);
-            if (_message.length() > 0) {
-                _message.append(", ");
-            }
-            _message.append(e.getClass().getSimpleName()).append(":").append(e.getMessage());
         }
         this.exceptions = Collections.unmodifiableList(_exceptions);
-        this.message = _message.toString();
+        this.message = count + " exceptions occurred. See them in causal chain below.";
+        this.cause = _cause;
     }
 
     public CompositeException(Collection errors) {
@@ -62,4 +59,51 @@ public List getExceptions() {
     public String getMessage() {
         return message;
     }
+
+    @Override
+    public synchronized Throwable getCause() {
+        return cause;
+    }
+
+    @SuppressWarnings("unused") // useful when debugging but don't want to make part of publicly supported API
+    private static String getStackTraceAsString(StackTraceElement[] stack) {
+        StringBuilder s = new StringBuilder();
+        boolean firstLine = true;
+        for (StackTraceElement e : stack) {
+            if (e.toString().startsWith("java.lang.Thread.getStackTrace")) {
+                // we'll ignore this one
+                continue;
+            }
+            if (!firstLine) {
+                s.append("\n\t");
+            }
+            s.append(e.toString());
+            firstLine = false;
+        }
+        return s.toString();
+    }
+
+    private static void attachCallingThreadStack(Throwable e, Throwable cause) {
+        while (e.getCause() != null) {
+            e = e.getCause();
+        }
+        // we now have 'e' as the last in the chain
+        try {
+            e.initCause(cause);
+        } catch (Throwable t) {
+            // ignore
+            // the javadocs say that some Throwables (depending on how they're made) will never
+            // let me call initCause without blowing up even if it returns null
+        }
+    }
+
+    private final static class CompositeExceptionCausalChain extends RuntimeException {
+        private static final long serialVersionUID = 3875212506787802066L;
+
+        @Override
+        public String getMessage() {
+            return "Chain of Causes for CompositeException In Order Received =>";
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java b/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java
index d59a6db6b3..ed1efd7d57 100644
--- a/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeObserverTest.java
@@ -22,6 +22,10 @@
 import org.junit.Test;
 
 import rx.Observer;
+import rx.subscriptions.Subscriptions;
+import rx.util.CompositeException;
+import rx.util.OnErrorNotImplementedException;
+import rx.util.functions.Action0;
 
 public class SafeObserverTest {
 
@@ -32,8 +36,9 @@ public void onNextFailure() {
             OBSERVER_ONNEXT_FAIL(onError).onNext("one");
             fail("expects exception to be thrown");
         } catch (Exception e) {
-            // expected
             assertNull(onError.get());
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("onNextFail", e.getMessage());
         }
     }
 
@@ -43,6 +48,8 @@ public void onNextFailureSafe() {
         try {
             new SafeObserver(OBSERVER_ONNEXT_FAIL(onError)).onNext("one");
             assertNotNull(onError.get());
+            assertTrue(onError.get() instanceof SafeObserverTestException);
+            assertEquals("onNextFail", onError.get().getMessage());
         } catch (Exception e) {
             fail("expects exception to be passed to onError");
         }
@@ -55,8 +62,9 @@ public void onCompletedFailure() {
             OBSERVER_ONCOMPLETED_FAIL(onError).onCompleted();
             fail("expects exception to be thrown");
         } catch (Exception e) {
-            // expected
             assertNull(onError.get());
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("onCompletedFail", e.getMessage());
         }
     }
 
@@ -66,6 +74,8 @@ public void onCompletedFailureSafe() {
         try {
             new SafeObserver(OBSERVER_ONCOMPLETED_FAIL(onError)).onCompleted();
             assertNotNull(onError.get());
+            assertTrue(onError.get() instanceof SafeObserverTestException);
+            assertEquals("onCompletedFail", onError.get().getMessage());
         } catch (Exception e) {
             fail("expects exception to be passed to onError");
         }
@@ -74,43 +84,262 @@ public void onCompletedFailureSafe() {
     @Test
     public void onErrorFailure() {
         try {
-            OBSERVER_ONERROR_FAIL().onError(new RuntimeException("error!"));
+            OBSERVER_ONERROR_FAIL().onError(new SafeObserverTestException("error!"));
             fail("expects exception to be thrown");
         } catch (Exception e) {
-            // expected
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("onErrorFail", e.getMessage());
         }
     }
 
     @Test
     public void onErrorFailureSafe() {
         try {
-            new SafeObserver(OBSERVER_ONERROR_FAIL()).onError(new RuntimeException("error!"));
+            new SafeObserver(OBSERVER_ONERROR_FAIL()).onError(new SafeObserverTestException("error!"));
             fail("expects exception to be thrown");
         } catch (Exception e) {
-            // expected since onError fails so SafeObserver can't help
+            e.printStackTrace();
+            assertTrue(e instanceof RuntimeException);
+            assertEquals("Error occurred when trying to propagate error to Observer.onError", e.getMessage());
+
+            Throwable e2 = e.getCause();
+            assertTrue(e2 instanceof CompositeException);
+            assertEquals("Chain of Causes for CompositeException In Order Received =>", e2.getCause().getMessage());
+
+            Throwable e3 = e2.getCause();
+            assertTrue(e3.getCause() instanceof SafeObserverTestException);
+            assertEquals("error!", e3.getCause().getMessage());
+
+            Throwable e4 = e3.getCause();
+            assertTrue(e4.getCause() instanceof SafeObserverTestException);
+            assertEquals("onErrorFail", e4.getCause().getMessage());
+        }
+    }
+
+    @Test
+    public void onErrorNotImplementedFailureSafe() {
+        try {
+            new SafeObserver(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeObserverTestException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            assertTrue(e instanceof OnErrorNotImplementedException);
+            assertTrue(e.getCause() instanceof SafeObserverTestException);
+            assertEquals("error!", e.getCause().getMessage());
         }
     }
 
     @Test
     public void onNextOnErrorFailure() {
         try {
-            OBSERVER_ONNEXT_ONERROR_FAIL().onError(new RuntimeException("error!"));
+            OBSERVER_ONNEXT_ONERROR_FAIL().onNext("one");
             fail("expects exception to be thrown");
         } catch (Exception e) {
-            // expected
+            e.printStackTrace();
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("onNextFail", e.getMessage());
         }
     }
 
     @Test
     public void onNextOnErrorFailureSafe() {
         try {
-            new SafeObserver(OBSERVER_ONNEXT_ONERROR_FAIL()).onError(new RuntimeException("error!"));
+            new SafeObserver(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one");
             fail("expects exception to be thrown");
         } catch (Exception e) {
+            e.printStackTrace();
+            assertTrue(e instanceof RuntimeException);
+            assertEquals("Error occurred when trying to propagate error to Observer.onError", e.getMessage());
+
+            Throwable e2 = e.getCause();
+            assertTrue(e2 instanceof CompositeException);
+            assertEquals("Chain of Causes for CompositeException In Order Received =>", e2.getCause().getMessage());
+
+            Throwable e3 = e2.getCause();
+            assertTrue(e3.getCause() instanceof SafeObserverTestException);
+            assertEquals("onNextFail", e3.getCause().getMessage());
+
+            Throwable e4 = e3.getCause();
+            assertTrue(e4.getCause() instanceof SafeObserverTestException);
+            assertEquals("onErrorFail", e4.getCause().getMessage());
+        }
+    }
+
+    @Test
+    public void onCompleteSuccessWithUnsubscribeFailure() {
+        SafeObservableSubscription s = null;
+        try {
+            s = new SafeObservableSubscription(Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    // break contract by throwing exception
+                    throw new SafeObserverTestException("failure from unsubscribe");
+                }
+            }));
+            new SafeObserver(s, OBSERVER_SUCCESS()).onCompleted();
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            e.printStackTrace();
+
+            assertTrue(s.isUnsubscribed());
+
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("failure from unsubscribe", e.getMessage());
             // expected since onError fails so SafeObserver can't help
         }
     }
 
+    @Test
+    public void onErrorSuccessWithUnsubscribeFailure() {
+        AtomicReference onError = new AtomicReference();
+        SafeObservableSubscription s = null;
+        try {
+            s = new SafeObservableSubscription(Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    // break contract by throwing exception
+                    throw new SafeObserverTestException("failure from unsubscribe");
+                }
+            }));
+            new SafeObserver(s, OBSERVER_SUCCESS(onError)).onError(new SafeObserverTestException("failed"));
+            fail("we expect the unsubscribe failure to cause an exception to be thrown");
+        } catch (Exception e) {
+            e.printStackTrace();
+
+            assertTrue(s.isUnsubscribed());
+
+            // we still expect onError to have received something before unsubscribe blew up
+            assertNotNull(onError.get());
+            assertTrue(onError.get() instanceof SafeObserverTestException);
+            assertEquals("failed", onError.get().getMessage());
+
+            // now assert the exception that was thrown
+            assertTrue(e instanceof SafeObserverTestException);
+            assertEquals("failure from unsubscribe", e.getMessage());
+        }
+    }
+
+    @Test
+    public void onErrorFailureWithUnsubscribeFailure() {
+        SafeObservableSubscription s = null;
+        try {
+            s = new SafeObservableSubscription(Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    // break contract by throwing exception
+                    throw new SafeObserverTestException("failure from unsubscribe");
+                }
+            }));
+            new SafeObserver(s, OBSERVER_ONERROR_FAIL()).onError(new SafeObserverTestException("onError failure"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            e.printStackTrace();
+
+            assertTrue(s.isUnsubscribed());
+
+            // assertions for what is expected for the actual failure propagated to onError which then fails
+            assertTrue(e instanceof RuntimeException);
+            assertEquals("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", e.getMessage());
+
+            Throwable e2 = e.getCause();
+            assertTrue(e2 instanceof CompositeException);
+            assertEquals("Chain of Causes for CompositeException In Order Received =>", e2.getCause().getMessage());
+
+            Throwable e3 = e2.getCause();
+            assertTrue(e3.getCause() instanceof SafeObserverTestException);
+            assertEquals("onError failure", e3.getCause().getMessage());
+
+            Throwable e4 = e3.getCause();
+            assertTrue(e4.getCause() instanceof SafeObserverTestException);
+            assertEquals("onErrorFail", e4.getCause().getMessage());
+
+            Throwable e5 = e4.getCause();
+            assertTrue(e5.getCause() instanceof SafeObserverTestException);
+            assertEquals("failure from unsubscribe", e5.getCause().getMessage());
+        }
+    }
+
+    @Test
+    public void onErrorNotImplementedFailureWithUnsubscribeFailure() {
+        SafeObservableSubscription s = null;
+        try {
+            s = new SafeObservableSubscription(Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    // break contract by throwing exception
+                    throw new SafeObserverTestException("failure from unsubscribe");
+                }
+            }));
+            new SafeObserver(s, OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeObserverTestException("error!"));
+            fail("expects exception to be thrown");
+        } catch (Exception e) {
+            e.printStackTrace();
+
+            assertTrue(s.isUnsubscribed());
+
+            // assertions for what is expected for the actual failure propagated to onError which then fails
+            assertTrue(e instanceof RuntimeException);
+            assertEquals("Observer.onError not implemented and error while unsubscribing.", e.getMessage());
+
+            Throwable e2 = e.getCause();
+            assertTrue(e2 instanceof CompositeException);
+            assertEquals("Chain of Causes for CompositeException In Order Received =>", e2.getCause().getMessage());
+
+            Throwable e3 = e2.getCause();
+            assertTrue(e3.getCause() instanceof SafeObserverTestException);
+            assertEquals("error!", e3.getCause().getMessage());
+
+            Throwable e4 = e3.getCause();
+            assertTrue(e4.getCause() instanceof SafeObserverTestException);
+            assertEquals("failure from unsubscribe", e4.getCause().getMessage());
+        }
+    }
+
+    private static Observer OBSERVER_SUCCESS() {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String args) {
+
+            }
+        };
+
+    }
+
+    private static Observer OBSERVER_SUCCESS(final AtomicReference onError) {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                onError.set(e);
+            }
+
+            @Override
+            public void onNext(String args) {
+
+            }
+        };
+
+    }
+
     private static Observer OBSERVER_ONNEXT_FAIL(final AtomicReference onError) {
         return new Observer() {
 
@@ -126,7 +355,7 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(String args) {
-                throw new RuntimeException("onNextFail");
+                throw new SafeObserverTestException("onNextFail");
             }
         };
 
@@ -142,12 +371,12 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                throw new RuntimeException("onErrortFail");
+                throw new SafeObserverTestException("onErrorFail");
             }
 
             @Override
             public void onNext(String args) {
-                throw new RuntimeException("onNextFail");
+                throw new SafeObserverTestException("onNextFail");
             }
 
         };
@@ -163,7 +392,28 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                throw new RuntimeException("onErrorFail");
+                throw new SafeObserverTestException("onErrorFail");
+            }
+
+            @Override
+            public void onNext(String args) {
+
+            }
+
+        };
+    }
+
+    private static Observer OBSERVER_ONERROR_NOTIMPLEMENTED() {
+        return new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new OnErrorNotImplementedException(e);
             }
 
             @Override
@@ -179,7 +429,7 @@ private static Observer OBSERVER_ONCOMPLETED_FAIL(final AtomicReference<
 
             @Override
             public void onCompleted() {
-                throw new RuntimeException("onCompletedFail");
+                throw new SafeObserverTestException("onCompletedFail");
             }
 
             @Override
@@ -194,4 +444,11 @@ public void onNext(String args) {
 
         };
     }
+
+    @SuppressWarnings("serial")
+    private static class SafeObserverTestException extends RuntimeException {
+        public SafeObserverTestException(String message) {
+            super(message);
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
index ce96b43edc..5bc08c34b2 100644
--- a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -17,10 +17,25 @@
 
 import static org.junit.Assert.*;
 
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Test;
 
+import rx.Observable;
+import rx.Observer;
+
 public class RxJavaPluginsTest {
 
+    @Before
+    public void resetBefore() {
+        RxJavaPlugins.getInstance().reset();
+    }
+
+    @After
+    public void resetAfter() {
+        RxJavaPlugins.getInstance().reset();
+    }
+
     @Test
     public void testErrorHandlerDefaultImpl() {
         RxJavaErrorHandler impl = new RxJavaPlugins().getErrorHandler();
@@ -50,7 +65,17 @@ public void testErrorHandlerViaProperty() {
 
     // inside test so it is stripped from Javadocs
     public static class RxJavaErrorHandlerTestImpl extends RxJavaErrorHandler {
-        // just use defaults
+
+        @SuppressWarnings("unused")
+        private volatile Throwable e;
+        private volatile int count = 0;
+
+        @Override
+        public void handleError(Throwable e) {
+            this.e = e;
+            count++;
+        }
+
     }
 
     @Test
@@ -81,6 +106,45 @@ public void testObservableExecutionHookViaProperty() {
         }
     }
 
+    @Test
+    public void testOnErrorWhenImplementedViaSubscribe() {
+        RxJavaErrorHandlerTestImpl errorHandler = new RxJavaErrorHandlerTestImpl();
+        RxJavaPlugins.getInstance().registerErrorHandler(errorHandler);
+
+        RuntimeException re = new RuntimeException("test onError");
+        Observable.error(re).subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onNext(Object args) {
+            }
+        });
+        assertEquals(re, errorHandler.e);
+        assertEquals(1, errorHandler.count);
+    }
+
+    @Test
+    public void testOnErrorWhenNotImplemented() {
+        RxJavaErrorHandlerTestImpl errorHandler = new RxJavaErrorHandlerTestImpl();
+        RxJavaPlugins.getInstance().registerErrorHandler(errorHandler);
+
+        RuntimeException re = new RuntimeException("test onError");
+        try {
+            Observable.error(re).subscribe();
+        } catch (Throwable e) {
+            // ignore as we expect it to throw
+        }
+        assertEquals(re, errorHandler.e);
+        assertEquals(1, errorHandler.count);
+    }
+
     // inside test so it is stripped from Javadocs
     public static class RxJavaObservableExecutionHookTestImpl extends RxJavaObservableExecutionHook {
         // just use defaults

From 5ef9075a491800fc7d9fa35b1f3f76d69d1b1169 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Thu, 9 Jan 2014 17:53:30 +0800
Subject: [PATCH 191/441] Replaced 'Thread.sleep' with 'CountDownLatch' to fix
 the flaky test failures

---
 .../rx/operators/OperationConcatTest.java     | 37 +++++++++----------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
index 24146ec131..05117231dc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
@@ -156,6 +156,7 @@ public void testNestedAsyncConcat() throws Throwable {
         final CountDownLatch allowThird = new CountDownLatch(1);
 
         final AtomicReference parent = new AtomicReference();
+        final CountDownLatch parentHasStarted = new CountDownLatch(1);
         Observable> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc>() {
 
             @Override
@@ -197,6 +198,7 @@ public void run() {
                     }
                 }));
                 parent.get().start();
+                parentHasStarted.countDown();
                 return s;
             }
         });
@@ -204,22 +206,14 @@ public void run() {
         Observable.create(concat(observableOfObservables)).subscribe(observer);
 
         // wait for parent to start
-        while (parent.get() == null) {
-            Thread.sleep(1);
-        }
+        parentHasStarted.await();
 
         try {
             // wait for first 2 async observables to complete
-            while (o1.t == null) {
-                Thread.sleep(1);
-            }
-            System.out.println("Thread1 started ... waiting for it to complete ...");
-            o1.t.join();
-            while (o2.t == null) {
-                Thread.sleep(1);
-            }
-            System.out.println("Thread2 started ... waiting for it to complete ...");
-            o2.t.join();
+            System.out.println("Thread1 is starting ... waiting for it to complete ...");
+            o1.waitForThreadDone();
+            System.out.println("Thread2 is starting ... waiting for it to complete ...");
+            o2.waitForThreadDone();
         } catch (Throwable e) {
             throw new RuntimeException("failed waiting on threads", e);
         }
@@ -243,11 +237,8 @@ public void run() {
         allowThird.countDown();
 
         try {
-            while (o3.t == null) {
-                Thread.sleep(1);
-            }
             // wait for 3rd to complete
-            o3.t.join();
+            o3.waitForThreadDone();
         } catch (Throwable e) {
             throw new RuntimeException("failed waiting on threads", e);
         }
@@ -320,9 +311,8 @@ public void testConcatConcurrentWithInfinity() {
 
         //Wait for the thread to start up.
         try {
-            Thread.sleep(25);
-            w1.t.join();
-            w2.t.join();
+            w1.waitForThreadDone();
+            w2.waitForThreadDone();
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
@@ -500,6 +490,7 @@ public void unsubscribe() {
         private boolean subscribed = true;
         private final CountDownLatch once;
         private final CountDownLatch okToContinue;
+        private final CountDownLatch threadHasStarted = new CountDownLatch(1);
         private final T seed;
         private final int size;
 
@@ -553,8 +544,14 @@ public void run() {
 
             });
             t.start();
+            threadHasStarted.countDown();
             return s;
         }
+
+        void waitForThreadDone() throws InterruptedException {
+            threadHasStarted.await();
+            t.join();
+        }
     }
     @Test
     public void testMultipleObservers() {

From 6c51edbb683ef44e563e0e7c5d2a587a2f99a7ac Mon Sep 17 00:00:00 2001
From: Christopher Grimm 
Date: Thu, 9 Jan 2014 16:09:09 -0500
Subject: [PATCH 192/441] ported groupByUntil function.

---
 .../main/scala/rx/lang/scala/Observable.scala | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index a39754e593..ca84a23b2f 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -1325,6 +1325,32 @@ trait Observable[+T]
     toScalaObservable[(K, Observable[T])](o1.map[(K, Observable[T])](func))
   }
 
+  /**
+   * Groups the items emitted by this Observable according to a specified discriminator function and terminates these groups
+   * according to a function.
+   *
+   * @param f
+   *            a function that extracts the key from an item
+   * @param closings
+   *            the function that accepts a created grouping and emits an observable which upon emitting a Closing, 
+   *            closes the group.
+   * @tparam K 
+   *            the type of the keys returned by the discriminator function.
+   * @tparam Closing
+   *            the type of the element emitted from the closings observable.
+   * @return an Observable that emits `(key, observable)`pairs, where `observable`
+   *         contains all items for which `f` returned `key` before `closings` emits a value.
+   */
+  def groupByUntil[K, Closing](f: T => K, closings: Observable[T]=>Observable[Closing]): Observable[(K, Observable[T])] = {
+    val closing = (o: rx.observables.GroupedObservable[K,T]) => closings(toScalaObservable[T](o)).asJavaObservable
+    val fclosing = new Func1[rx.observables.GroupedObservable[K, T], rx.Observable[_ <: Closing]] {
+      def call(o: rx.observables.GroupedObservable[K, T]) = closing(o)
+    }.asInstanceOf[Func1[_ >: rx.observables.GroupedObservable[K, _ <: T], _ <: rx.Observable[Closing]]]
+    val o1 = asJavaObservable.groupByUntil[K, Closing](f, fclosing) : rx.Observable[_ <: rx.observables.GroupedObservable[K, _ <: T]]
+    val func = (o: rx.observables.GroupedObservable[K, _ <: T]) => (o.getKey, toScalaObservable[T](o))
+    toScalaObservable[(K, Observable[T])](o1.map[(K, Observable[T])](func))
+  }
+
   /**
    * Given an Observable that emits Observables, creates a single Observable that
    * emits the items emitted by the most recently published of those Observables.

From 93c9fcc0028c042c36d0ee0693764d688fe83587 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Fri, 10 Jan 2014 11:42:29 +0100
Subject: [PATCH 193/441] Buffer with Observable boundary.

---
 rxjava-core/src/main/java/rx/Observable.java  |  29 ++++
 .../java/rx/operators/OperationBuffer.java    | 136 ++++++++++++++++++
 .../rx/operators/OperationBufferTest.java     | 133 ++++++++++++++++-
 3 files changed, 296 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..6b039d74fa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3076,6 +3076,35 @@ public static  Observable combineLates
         return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, o9, combineFunction));
     }
 
+    /**
+     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
+     * 
    
+     * Completion of either this or the boundary observable causes the returned observable
+     * to emit the latest buffer and complete.
+     * @param  the boundary value type (ignored)
+     * @param boundary the boundary observable
+     * @return an Observable that emits buffered items once the boundary observable emits an item.
+     * @see #buffer(rx.Observable, int) 
+     */
+    public  Observable> buffer(Observable boundary) {
+        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
+    }
+    
+    /**
+     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
+     * 
    
+     * Completion of either this or the boundary observable causes the returned observable
+     * to emit the latest buffer and complete.
+     * @param  the boundary value type (ignored)
+     * @param boundary the boundary observable
+     * @param initialCapacity the initial capacity of each buffer chunk
+     * @return an Observable that emits buffered items once the boundary observable emits an item.
+     * @see #buffer(rx.Observable, int) 
+     */
+    public  Observable> buffer(Observable boundary, int initialCapacity) {
+        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
+    }
+    
     /**
      * Creates an Observable that emits buffers of items it collects from the
      * source Observable. The resulting Observable emits connected,
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index d7c63df23e..4259bf8910 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -397,4 +398,139 @@ public void unsubscribe() {
             }
         }
     }
+    
+    /**
+     * Create a buffer operator with the given observable sequence as the buffer boundary.
+     */
+    public static  OnSubscribeFunc> bufferWithBoundaryObservable(Observable source, Observable boundary) {
+        return new BufferWithObservableBoundary(source, boundary, 16);
+    }
+    /**
+     * Create a buffer operator with the given observable sequence as the buffer boundary and
+     * with the given initial capacity for buffers.
+     */
+    public static  OnSubscribeFunc> bufferWithBoundaryObservable(Observable source, Observable boundary, int initialCapacity) {
+        if (initialCapacity <= 0) {
+            throw new IllegalArgumentException("initialCapacity > 0 required");
+        }
+        return new BufferWithObservableBoundary(source, boundary, initialCapacity);
+    }
+    
+    /**
+     * Buffer until an element is emitted from a helper observable.
+     * @param  the buffered value type
+     */
+    private static final class BufferWithObservableBoundary implements OnSubscribeFunc> {
+        final Observable source;
+        final Observable boundary;
+        final int initialCapacity;
+
+        public BufferWithObservableBoundary(Observable source, Observable boundary, int initialCapacity) {
+            this.source = source;
+            this.boundary = boundary;
+            this.initialCapacity = initialCapacity;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer> t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+            
+            SourceObserver so = new SourceObserver(t1, initialCapacity, csub);
+            csub.add(source.subscribe(so));
+            csub.add(boundary.subscribe(new BoundaryObserver(so)));
+            
+            return csub;
+        }
+        /**
+         * Observes the source.
+         */
+        private static final class SourceObserver implements Observer {
+            final Observer> observer;
+            /** The buffer, if null, that indicates a terminal state. */
+            List buffer;
+            final int initialCapacity;
+            final Object guard;
+            final Subscription cancel;
+            public SourceObserver(Observer> observer, int initialCapacity, Subscription cancel) {
+                this.observer = observer;
+                this.initialCapacity = initialCapacity;
+                this.guard = new Object();
+                this.cancel = cancel;
+                buffer = new ArrayList(initialCapacity);
+            }
+
+            @Override
+            public void onNext(T args) {
+                synchronized (guard) {
+                    buffer.add(args);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (guard) {
+                    if (buffer == null) {
+                        return;
+                    }
+                    buffer = null;
+                }
+                observer.onError(e);
+                cancel.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                emitAndComplete();
+                cancel.unsubscribe();
+            }
+            void emitAndReplace() {
+                List buf;
+                synchronized (guard) {
+                    if (buffer == null) {
+                        return;
+                    }
+                    buf = buffer;
+                    buffer = new ArrayList(initialCapacity);
+                }
+                observer.onNext(buf);
+            }
+            void emitAndComplete() {
+                List buf;
+                synchronized (guard) {
+                    if (buffer == null) {
+                        return;
+                    }
+                    buf = buffer;
+                    buffer = null;
+                }
+                observer.onNext(buf);
+                observer.onCompleted();
+            }
+        }
+        /**
+         * Observes the boundary.
+         */
+        private static final class BoundaryObserver implements Observer {
+            final SourceObserver so;
+
+            public BoundaryObserver(SourceObserver so) {
+                this.so = so;
+            }
+
+            @Override
+            public void onNext(T args) {
+                so.emitAndReplace();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                so.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                so.onCompleted();
+            }
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index dc45a16a8f..eb9a4fee5d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -28,13 +28,13 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.*;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
@@ -383,4 +383,133 @@ public void testBufferStopsWhenUnsubscribed1() {
         
         inOrder.verifyNoMoreInteractions();
     }
+    
+    @Test
+    public void bufferWithBONormal1() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = Mockito.inOrder(o);
+        
+        source.buffer(boundary).subscribe(o);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        
+        boundary.onNext(1);
+
+        inOrder.verify(o, times(1)).onNext(Arrays.asList(1, 2, 3));
+
+        source.onNext(4);
+        source.onNext(5);
+        
+        boundary.onNext(2);
+        
+        inOrder.verify(o, times(1)).onNext(Arrays.asList(4, 5));
+
+        source.onNext(6);
+        boundary.onCompleted();
+        
+        inOrder.verify(o, times(1)).onNext(Arrays.asList(6));
+        
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void bufferWithBOEmptyLastViaBoundary() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = Mockito.inOrder(o);
+        
+        source.buffer(boundary).subscribe(o);
+        
+        boundary.onCompleted();
+        
+        inOrder.verify(o, times(1)).onNext(Arrays.asList());
+        
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void bufferWithBOEmptyLastViaSource() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = Mockito.inOrder(o);
+        
+        source.buffer(boundary).subscribe(o);
+        
+        source.onCompleted();
+        
+        inOrder.verify(o, times(1)).onNext(Arrays.asList());
+        
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void bufferWithBOEmptyLastViaBoth() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = Mockito.inOrder(o);
+        
+        source.buffer(boundary).subscribe(o);
+        
+        source.onCompleted();
+        boundary.onCompleted();
+        
+        inOrder.verify(o, times(1)).onNext(Arrays.asList());
+        
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void bufferWithBOSourceThrows() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        source.buffer(boundary).subscribe(o);
+        source.onNext(1);
+        source.onError(new OperationReduceTest.CustomException());
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+    }
+    
+    @Test
+    public void bufferWithBOBoundaryThrows() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        source.buffer(boundary).subscribe(o);
+        
+        source.onNext(1);
+        boundary.onError(new OperationReduceTest.CustomException());
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+    }
 }

From 40e851b963da58ababfe864286ae0dcb612e3148 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Fri, 10 Jan 2014 13:22:47 +0100
Subject: [PATCH 194/441] Delay with subscription and item delaying
 observables.

---
 rxjava-core/src/main/java/rx/Observable.java  |  44 +++
 .../java/rx/operators/OperationDelay.java     | 195 ++++++++++++
 .../java/rx/operators/OperationDelayTest.java | 286 ++++++++++++++++++
 3 files changed, 525 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..87bce6ba27 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2167,6 +2167,50 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
         return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler));
     }
 
+    /**
+     * Create an Observable which delays the events via another Observable on a per item-basis.
+     * 
    
+     * Note: onError or onCompleted events are immediately propagated.
+     * 
    
+     * Note: if the Observable returned by the {@code itemDelay} just completes, that
+     * particular source item is not emitted.
+     * 
+     * @param  the item delay value type (ignored)
+     * @param itemDelay function that returns an Observable for each source item which is
+     *                  then used for delaying that particular item until the Observable
+     *                  fires its first onNext event.
+     * @return an Observable which delays the events via another Observable on a per item-basis.
+     */
+    public  Observable delay(Func1> itemDelay) {
+        return create(OperationDelay.delay(this, itemDelay));
+    }
+    /**
+     * Create an Observable which delays the subscription and events via another Observables on a per item-basis.
+     * 
    
+     * Note: onError or onCompleted events are immediately propagated.
+     * 
    
+     * Note: if the Observable returned by the {@code itemDelay} just completes, that
+     * particular source item is not emitted.
+     * 
    
+     * Note: if the {@code subscriptionDelay}'s Observable just completes, the created
+     * observable will just complete as well.
+     * 
+     * @param  the subscription delay value type (ignored)
+     * @param  the item delay value type (ignored)
+     * @param subscriptionDelay function that returns an Observable which will trigger
+     *                          the subscription to the source observable once it fires an
+     *                          onNext event.
+     * @param itemDelay function that returns an Observable for each source item which is
+     *                  then used for delaying that particular item until the Observable
+     *                  fires its first onNext event.
+     * @return an Observable which delays the events via another Observable on a per item-basis.
+     */
+    public  Observable delay(
+            Func0> subscriptionDelay,
+            Func1> itemDelay) {
+        return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
+    }
+    
     /**
      * Returns an Observable that emits the items emitted by the source
      * Observable shifted forward in time by a specified delay. Error
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 4594adda76..56d9de1cb3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -23,8 +23,11 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.observables.ConnectableObservable;
+import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
+import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
 public final class OperationDelay {
@@ -82,4 +85,196 @@ public void call() {
             return ssub;
         }
     }
+    /**
+     * Delay the emission of the source items by a per-item observable that fires its first element.
+     */
+    public static  OnSubscribeFunc delay(Observable source, 
+            Func1> itemDelay) {
+        return new DelayViaObservable(source, null, itemDelay);
+    }
+    /**
+     * Delay the subscription and emission of the source items by a per-item observable that fires its first element.
+     */
+    public static  OnSubscribeFunc delay(Observable source, 
+            Func0> subscriptionDelay,
+            Func1> itemDelay) {
+        return new DelayViaObservable(source, subscriptionDelay, itemDelay);
+    }
+    /**
+     * Delay the emission of the source items by a per-item observable that fires its first element.
+     */
+    private static final class DelayViaObservable implements OnSubscribeFunc {
+        final Observable source;
+        final Func0> subscriptionDelay;
+        final Func1> itemDelay;
+
+        public DelayViaObservable(Observable source, 
+                Func0> subscriptionDelay,
+                Func1> itemDelay) {
+            this.source = source;
+            this.subscriptionDelay = subscriptionDelay;
+            this.itemDelay = itemDelay;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+            
+            if (subscriptionDelay == null) {
+                csub.add(source.subscribe(new SourceObserver(t1, itemDelay, csub)));
+            } else {
+                Observable subscriptionSource;
+                try {
+                    subscriptionSource = subscriptionDelay.call();
+                } catch (Throwable t) {
+                    t1.onError(t);
+                    return Subscriptions.empty();
+                }
+                SerialSubscription ssub = new SerialSubscription();
+                csub.add(ssub);
+                ssub.set(subscriptionSource.subscribe(new SubscribeDelay(source, t1, itemDelay, csub, ssub)));
+            }
+            
+            return csub;
+        }
+        private static final class SubscribeDelay implements Observer {
+            final Observable source;
+            final Observer observer;
+            final Func1> itemDelay;
+            final CompositeSubscription csub;
+            final Subscription self;
+            /** Prevent any onError and onCompleted once the first item was delivered. */
+            boolean subscribed;
+
+            public SubscribeDelay(Observable source, Observer observer, Func1> itemDelay, 
+                    CompositeSubscription csub, Subscription self) {
+                this.source = source;
+                this.observer = observer;
+                this.itemDelay = itemDelay;
+                this.csub = csub;
+                this.self = self;
+            }
+
+            @Override
+            public void onNext(U args) {
+                subscribed = true;
+                csub.remove(self);
+                csub.add(source.subscribe(new SourceObserver(observer, itemDelay, csub)));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (!subscribed) {
+                    observer.onError(e);
+                    csub.unsubscribe();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!subscribed) {
+                    observer.onCompleted();
+                    csub.unsubscribe();
+                }
+            }
+        }
+        /** The source observer. */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final Func1> itemDelay;
+            final CompositeSubscription csub;
+            /** Guard to avoid overlapping events from the various sources. */
+            final Object guard;
+            boolean done;
+
+            public SourceObserver(Observer observer, Func1> itemDelay, CompositeSubscription csub) {
+                this.observer = observer;
+                this.itemDelay = itemDelay;
+                this.csub = csub;
+                this.guard = new Object();
+            }
+
+            @Override
+            public void onNext(T args) {
+                Observable delayer;
+                try {
+                    delayer = itemDelay.call(args);
+                } catch (Throwable t) {
+                    onError(t);
+                    return;
+                }
+                SerialSubscription ssub = new SerialSubscription();
+                csub.add(ssub);
+                
+                ssub.set(delayer.subscribe(new DelayObserver(args, this, ssub)));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    observer.onError(e);
+                }
+                csub.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    observer.onCompleted();
+                }
+                csub.unsubscribe();
+            }
+            
+            public void emit(T value, Subscription token) {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    observer.onNext(value);
+                }
+                remove(token);
+            }
+            public void remove(Subscription token) {
+                csub.remove(token);
+            }
+        }
+        /**
+         * Delay observer.
+         */
+        private static final class DelayObserver implements Observer {
+            final T value;
+            final SourceObserver parent;
+            final Subscription token;
+
+            public DelayObserver(T value, SourceObserver parent, Subscription token) {
+                this.value = value;
+                this.parent = parent;
+                this.token = token;
+            }
+
+            @Override
+            public void onNext(U args) {
+                parent.emit(value, token);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                parent.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                parent.remove(token);
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
index 10fdd459bd..f040a012c2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
@@ -15,6 +15,8 @@
  */
 package rx.operators;
 
+import java.util.ArrayList;
+import java.util.List;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyLong;
 import static org.mockito.Mockito.inOrder;
@@ -36,6 +38,8 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
+import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
 public class OperationDelayTest {
@@ -235,4 +239,286 @@ public void testDelaySubscriptionCancelBeforeTime() {
         verify(o, never()).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
+    
+    @Test
+    public void testDelayWithObservableNormal1() {
+        PublishSubject source = PublishSubject.create();
+        final List> delays = new ArrayList>();
+        final int n = 10;
+        for (int i = 0; i < n; i++) {
+            PublishSubject delay = PublishSubject.create();
+            delays.add(delay);
+        }
+
+        Func1> delayFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return delays.get(t1);
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.delay(delayFunc).subscribe(o);
+        
+        
+        for (int i = 0; i < n; i++) {
+            source.onNext(i);
+            delays.get(i).onNext(i);
+            inOrder.verify(o).onNext(i);
+        }
+        source.onCompleted();
+        
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testDelayWithObservableSkipper1() {
+        PublishSubject source = PublishSubject.create();
+        final List> delays = new ArrayList>();
+        final int n = 10;
+        for (int i = 0; i < n; i++) {
+            PublishSubject delay = PublishSubject.create();
+            delays.add(delay);
+        }
+
+        Func1> delayFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return delays.get(t1);
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.delay(delayFunc).subscribe(o);
+        
+        
+        for (int i = 0; i < n; i++) {
+            source.onNext(i);
+            if (i % 2 == 0) {
+                delays.get(i).onNext(i);
+                inOrder.verify(o).onNext(i);
+            } else {
+                delays.get(i).onCompleted();
+                inOrder.verify(o, never()).onNext(i);
+            }
+        }
+        source.onCompleted();
+        
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testDelayWithObservableSingleSend1() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        delay.onNext(1);
+        delay.onNext(2);
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testDelayWithObservableSourceThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(delayFunc).subscribe(o);
+        source.onNext(1);
+        source.onError(new OperationReduceTest.CustomException());
+        delay.onNext(1);
+
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testDelayWithObservableDelayFunctionThrows() {
+        PublishSubject source = PublishSubject.create();
+
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(delayFunc).subscribe(o);
+        source.onNext(1);
+
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    
+    @Test
+    public void testDelayWithObservableDelayThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(delayFunc).subscribe(o);
+        source.onNext(1);
+        delay.onError(new OperationReduceTest.CustomException());
+
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testDelayWithObservableSubscriptionNormal() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+        Func0> subFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return delay;
+            }
+        };
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(subFunc, delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        delay.onNext(1);
+
+        source.onNext(2);
+        delay.onNext(2);
+        
+        inOrder.verify(o).onNext(2);
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testDelayWithObservableSubscriptionFunctionThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+        Func0> subFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(subFunc, delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        delay.onNext(1);
+
+        source.onNext(2);
+        
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testDelayWithObservableSubscriptionThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+        Func0> subFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return delay;
+            }
+        };
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(subFunc, delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        delay.onError(new OperationReduceTest.CustomException());
+
+        source.onNext(2);
+        
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
 }

From 82c0aec29b46ebfb27528bbeb0f7a732039bca2d Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Fri, 10 Jan 2014 14:33:14 +0100
Subject: [PATCH 195/441] Window with Observable boundary.

---
 rxjava-core/src/main/java/rx/Observable.java  |  15 ++
 .../java/rx/operators/OperationWindow.java    | 144 ++++++++++++
 .../rx/operators/OperationWindowTest.java     | 221 ++++++++++++++++++
 3 files changed, 380 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..896150e8d1 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3373,6 +3373,21 @@ public  Observable> window(Observable the window element type (ignored)
+     * @param boundary the Observable sequence whose emitted item is used for closing
+     *                 and opening windows
+     * @return an Observable which emits non-overlapping windows of items it collects from the
+     * source observable where the boundary of each window is determined by the items
+     * emitted from the boundary observable
+     */
+    public  Observable> window(Observable boundary) {
+        return create(OperationWindow.window(this, boundary));
+    }
+    
     /**
      * Creates an Observable that emits windows of items it collects from the
      * source Observable. The resulting Observable emits connected,
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index ef867898ed..c1026241a2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -23,6 +23,10 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+import rx.subjects.Subject;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
@@ -354,4 +358,144 @@ public Observable getContents() {
             return Observable.from(contents);
         }
     }
+    /**
+     * Emits windows of values of the source Observable where the window boundary is
+     * determined by the items of the boundary Observable.
+     */
+    public static  OnSubscribeFunc> window(Observable source, Observable boundary) {
+        return new WindowViaObservable(source, boundary);
+    }
+    /**
+     * Create non-overlapping windows from the source values by using another observable's
+     * values as to when to replace a window.
+     */
+    private static final class WindowViaObservable implements OnSubscribeFunc> {
+        final Observable source;
+        final Observable boundary;
+
+        public WindowViaObservable(Observable source, Observable boundary) {
+            this.source = source;
+            this.boundary = boundary;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer> t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+
+            final SourceObserver so = new SourceObserver(t1, csub);
+            try {
+                t1.onNext(so.subject);
+            } catch (Throwable t) {
+                t1.onError(t);
+                return Subscriptions.empty();
+            }
+            csub.add(source.subscribe(so));
+            
+            if (!csub.isUnsubscribed()) {
+                csub.add(boundary.subscribe(new BoundaryObserver(so)));
+            }
+            
+            return csub;
+        }
+        /**
+         * Observe the source and emit the values into the current window.
+         */
+        private static final class SourceObserver implements Observer {
+            final Observer> observer;
+            final Subscription cancel;
+            final Object guard;
+            Subject subject;
+
+            public SourceObserver(Observer> observer, Subscription cancel) {
+                this.observer = observer;
+                this.cancel = cancel;
+                this.guard = new Object();
+                this.subject = create();
+            }
+
+            Subject create() {
+                return PublishSubject.create();
+            }
+            @Override
+            public void onNext(T args) {
+                synchronized (guard) {
+                    if (subject == null) {
+                        return;
+                    }
+                    subject.onNext(args);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (guard) {
+                    if (subject == null) {
+                        return;
+                    }
+                    Subject s = subject;
+                    subject = null;
+    
+                    s.onError(e);
+                    observer.onError(e);
+                }
+                cancel.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                synchronized (guard) {
+                    if (subject == null) {
+                        return;
+                    }
+                    Subject s = subject;
+                    subject = null;
+                    
+                    s.onCompleted();
+                    observer.onCompleted();
+                }
+                cancel.unsubscribe();
+            }
+            public void replace() {
+                try {
+                    synchronized (guard) {
+                        if (subject == null) {
+                            return;
+                        }
+                        Subject s = subject;
+                        s.onCompleted();
+
+                        subject = create();
+                        observer.onNext(subject);
+                    }
+                } catch (Throwable t) {
+                    onError(t);
+                }
+            }
+        }
+        /**
+         * Observe the boundary and replace the window on each item.
+         */
+        private static final class BoundaryObserver implements Observer {
+            final SourceObserver so;
+
+            public BoundaryObserver(SourceObserver so) {
+                this.so = so;
+            }
+
+            @Override
+            public void onNext(U args) {
+                so.replace();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                so.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                so.onCompleted();
+            }
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index ebe26dacba..4886ed1661 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -24,12 +24,14 @@
 
 import org.junit.Before;
 import org.junit.Test;
+import static org.mockito.Mockito.*;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
@@ -321,4 +323,223 @@ public void onNext(String args) {
             }
         };
     }
+    @Test
+    public void testWindowViaObservableNormal1() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+
+        @SuppressWarnings("unchecked")
+        final Observer o = mock(Observer.class);
+        
+        final List> values = new ArrayList>();
+        
+        Observer> wo = new Observer>() {
+            @Override
+            public void onNext(Observable args) {
+                @SuppressWarnings("unchecked")
+                final Observer mo = mock(Observer.class);
+                values.add(mo);
+                
+                args.subscribe(mo);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        };
+        
+        source.window(boundary).subscribe(wo);
+
+        int n = 30;
+        for (int i = 0; i < n; i++) {
+            source.onNext(i);
+            if (i % 3 == 2 && i < n - 1) {
+                boundary.onNext(i / 3);
+            }
+        }
+        source.onCompleted();
+
+        assertEquals(n / 3, values.size());
+        
+        int j = 0;
+        for (Observer mo : values) {
+            for (int i = 0; i < 3; i++) {
+                verify(mo).onNext(j + i);
+            }
+            verify(mo).onCompleted();
+            verify(mo, never()).onError(any(Throwable.class));
+            j += 3;
+        }
+        
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testWindowViaObservableBoundaryCompletes() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+
+        @SuppressWarnings("unchecked")
+        final Observer o = mock(Observer.class);
+        
+        final List> values = new ArrayList>();
+        
+        Observer> wo = new Observer>() {
+            @Override
+            public void onNext(Observable args) {
+                @SuppressWarnings("unchecked")
+                final Observer mo = mock(Observer.class);
+                values.add(mo);
+                
+                args.subscribe(mo);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        };
+        
+        source.window(boundary).subscribe(wo);
+
+        int n = 30;
+        for (int i = 0; i < n; i++) {
+            source.onNext(i);
+            if (i % 3 == 2 && i < n - 1) {
+                boundary.onNext(i / 3);
+            }
+        }
+        boundary.onCompleted();
+
+        assertEquals(n / 3, values.size());
+        
+        int j = 0;
+        for (Observer mo : values) {
+            for (int i = 0; i < 3; i++) {
+                verify(mo).onNext(j + i);
+            }
+            verify(mo).onCompleted();
+            verify(mo, never()).onError(any(Throwable.class));
+            j += 3;
+        }
+        
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testWindowViaObservableBoundaryThrows() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+
+        @SuppressWarnings("unchecked")
+        final Observer o = mock(Observer.class);
+        
+        final List> values = new ArrayList>();
+        
+        Observer> wo = new Observer>() {
+            @Override
+            public void onNext(Observable args) {
+                @SuppressWarnings("unchecked")
+                final Observer mo = mock(Observer.class);
+                values.add(mo);
+                
+                args.subscribe(mo);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        };
+        
+        source.window(boundary).subscribe(wo);
+
+        source.onNext(0);
+        source.onNext(1);
+        source.onNext(2);
+
+        boundary.onError(new OperationReduceTest.CustomException());
+
+        assertEquals(1, values.size());
+        
+        Observer mo = values.get(0);
+        
+        verify(mo).onNext(0);
+        verify(mo).onNext(1);
+        verify(mo).onNext(2);
+        verify(mo).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    
+    @Test
+    public void testWindowViaObservableourceThrows() {
+        PublishSubject source = PublishSubject.create();
+        PublishSubject boundary = PublishSubject.create();
+
+        @SuppressWarnings("unchecked")
+        final Observer o = mock(Observer.class);
+        
+        final List> values = new ArrayList>();
+        
+        Observer> wo = new Observer>() {
+            @Override
+            public void onNext(Observable args) {
+                @SuppressWarnings("unchecked")
+                final Observer mo = mock(Observer.class);
+                values.add(mo);
+                
+                args.subscribe(mo);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        };
+        
+        source.window(boundary).subscribe(wo);
+
+        source.onNext(0);
+        source.onNext(1);
+        source.onNext(2);
+
+        source.onError(new OperationReduceTest.CustomException());
+
+        assertEquals(1, values.size());
+        
+        Observer mo = values.get(0);
+        
+        verify(mo).onNext(0);
+        verify(mo).onNext(1);
+        verify(mo).onNext(2);
+        verify(mo).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
 }

From dd7c4ce98ca40b0f154a618a6d70a9699e675fcc Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Fri, 10 Jan 2014 15:42:40 +0100
Subject: [PATCH 196/441] MergeMap with Iterable and resultSelector overloads

---
 rxjava-core/src/main/java/rx/Observable.java  |  45 ++++
 .../java/rx/operators/OperationFlatMap.java   | 208 ++++++++++++++++++
 .../rx/operators/OperationFlatMapTest.java    | 145 ++++++++++++
 3 files changed, 398 insertions(+)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..a1227b9ef6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -53,6 +53,7 @@
 import rx.operators.OperationElementAt;
 import rx.operators.OperationFilter;
 import rx.operators.OperationFinally;
+import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupBy;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
@@ -3856,6 +3857,50 @@ public  Observable mergeMap(Func1 the element type of the collection Observable
+     * @param  the result type
+     * @param collectionSelector function that returns an Observable sequence for each value in the source Observable
+     * @param resultSelector function that combines the values of the source and collection Observable
+     * @return an Observable that applies a function to the pair of values from the source
+     * Observable and the collection Observable.
+     */
+    public  Observable mergeMap(Func1> collectionSelector,
+            Func2 resultSelector) {
+        return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
+    }
+    
+    /**
+     * Create an Observable that merges the values of the iterables returned by the
+     * collectionSelector for each source value.
+     * @param  the result value type
+     * @param collectionSelector function that returns an Iterable sequence of values for
+     * each source value.
+     * @return an Observable that merges the values of the iterables returned by the
+     * collectionSelector for each source value.
+     */
+    public  Observable mergeMapIterable(Func1> collectionSelector) {
+        return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
+    }
+    
+    /**
+     * Create an Observable that applies a function to the pair of values from the source
+     * Observable and the collection Iterable sequence.
+     * @param  the collection element type
+     * @param  the result type
+     * @param collectionSelector function that returns an Iterable sequence of values for
+     * each source value.
+     * @param resultSelector function that combines the values of the source and collection Iterable
+     * @return n Observable that applies a function to the pair of values from the source
+     * Observable and the collection Iterable sequence.
+     */
+    public  Observable mergeMapIterable(Func1> collectionSelector,
+            Func2 resultSelector) {
+        return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
+    }
+    
     /**
      * Creates a new Observable by applying a function that you supply to each
      * item emitted by the source Observable, where that function returns an
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
new file mode 100644
index 0000000000..20c12993cb
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -0,0 +1,208 @@
+/**
+ * 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 java.util.concurrent.atomic.AtomicInteger;
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.SerialSubscription;
+import rx.util.functions.Func1;
+import rx.util.functions.Func2;
+
+/**
+ * Additional flatMap operators.
+ */
+public final class OperationFlatMap {
+    /** Utility class. */
+    private OperationFlatMap() { throw new IllegalStateException("No instances!"); }
+    
+    /**
+     * Observable that pairs up the source values and all the derived collection
+     * values and projects them via the selector.
+     */
+    public static  OnSubscribeFunc flatMap(Observable source,
+            Func1> collectionSelector,
+            Func2 resultSelector
+            ) {
+        return new FlatMapPairSelector(source, collectionSelector, resultSelector);
+    }
+    /**
+     * Converts the result Iterable of a function into an Observable.
+     */
+    public static  Func1> flatMapIterableFunc(
+            Func1> collectionSelector) {
+        return new IterableToObservableFunc(collectionSelector);
+    }
+    /**
+     * Converts the result Iterable of a function into an Observable.
+     * @param  the parameter type
+     * @param  the result type
+     */
+    private static final class IterableToObservableFunc implements Func1> {
+        final Func1> func;
+
+        public IterableToObservableFunc(Func1> func) {
+            this.func = func;
+        }
+
+        @Override
+        public Observable call(T t1) {
+            return Observable.from(func.call(t1));
+        }
+    }
+    /**
+     * Pairs up the source value with each of the associated observable values
+     * and uses a selector function to calculate the result sequence.
+     * @param  the source value type
+     * @param  the collection value type
+     * @param  the result type
+     */
+    private static final class FlatMapPairSelector implements OnSubscribeFunc {
+        final Observable source;
+        final Func1> collectionSelector;
+        final Func2 resultSelector;
+
+        public FlatMapPairSelector(Observable source, Func1> collectionSelector, Func2 resultSelector) {
+            this.source = source;
+            this.collectionSelector = collectionSelector;
+            this.resultSelector = resultSelector;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+            
+            csub.add(source.subscribe(new SourceObserver(t1, collectionSelector, resultSelector, csub)));
+            
+            return csub;
+        }
+        
+        /** Observes the source, starts the collections and projects the result. */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final Func1> collectionSelector;
+            final Func2 resultSelector;
+            final CompositeSubscription csub;
+            final AtomicInteger wip;
+            /** Don't let various events run at the same time. */
+            final Object guard;
+            boolean done;
+
+            public SourceObserver(Observer observer, Func1> collectionSelector, Func2 resultSelector, CompositeSubscription csub) {
+                this.observer = observer;
+                this.collectionSelector = collectionSelector;
+                this.resultSelector = resultSelector;
+                this.csub = csub;
+                this.wip = new AtomicInteger(1);
+                this.guard = new Object();
+            }
+
+            @Override
+            public void onNext(T args) {
+                Observable coll;
+                try {
+                    coll = collectionSelector.call(args);
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                
+                SerialSubscription ssub = new SerialSubscription();
+                csub.add(ssub);
+                wip.incrementAndGet();
+                
+                ssub.set(coll.subscribe(new CollectionObserver(this, args, ssub)));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    observer.onError(e);
+                }
+                csub.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                if (wip.decrementAndGet() == 0) {
+                    synchronized (guard) {
+                        if (done) {
+                            return;
+                        }
+                        done = true;
+                        observer.onCompleted();
+                    }
+                    csub.unsubscribe();
+                }
+            }
+            
+            void complete(Subscription s) {
+                csub.remove(s);
+                onCompleted();
+            }
+            
+            void emit(T t, U u) {
+                R r;
+                try {
+                    r = resultSelector.call(t, u);
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    observer.onNext(r);
+                }
+            }
+        }
+        /** Observe a collection and call emit with the pair of the key and the value. */
+        private static final class CollectionObserver implements Observer {
+            final SourceObserver so;
+            final Subscription cancel;
+            final T value;
+
+            public CollectionObserver(SourceObserver so, T value, Subscription cancel) {
+                this.so = so;
+                this.value = value;
+                this.cancel = cancel;
+            }
+
+            @Override
+            public void onNext(U args) {
+                so.emit(value, args);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                so.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                so.complete(cancel);
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
new file mode 100644
index 0000000000..9c3afd73f7
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
@@ -0,0 +1,145 @@
+/**
+ * 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 java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.util.functions.Func1;
+import rx.util.functions.Func2;
+
+public class OperationFlatMapTest {
+    @Test
+    public void testNormal() {
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        final List list = Arrays.asList(1, 2, 3);
+        
+        Func1> func = new Func1>() {
+            @Override
+            public List call(Integer t1) {
+                return list;
+            }
+        };
+        Func2 resFunc = new Func2() {
+
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t1 | t2;
+            }
+        };
+        
+        List source = Arrays.asList(16, 32, 64);
+        
+        Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
+
+        for (Integer s : source) {
+            for (Integer v : list) {
+                verify(o).onNext(s | v);
+            }
+        }
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testCollectionFunctionThrows() {
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        Func1> func = new Func1>() {
+            @Override
+            public List call(Integer t1) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        Func2 resFunc = new Func2() {
+
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t1 | t2;
+            }
+        };
+        
+        List source = Arrays.asList(16, 32, 64);
+        
+        Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
+        
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    
+    @Test
+    public void testResultFunctionThrows() {
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        final List list = Arrays.asList(1, 2, 3);
+        
+        Func1> func = new Func1>() {
+            @Override
+            public List call(Integer t1) {
+                return list;
+            }
+        };
+        Func2 resFunc = new Func2() {
+
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        
+        List source = Arrays.asList(16, 32, 64);
+        
+        Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
+        
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    @Test
+    public void testMergeError() {
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+
+        Func1> func = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return Observable.error(new OperationReduceTest.CustomException());
+            }
+        };
+        Func2 resFunc = new Func2() {
+
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t1 | t2;
+            }
+        };
+        
+        List source = Arrays.asList(16, 32, 64);
+        
+        Observable.from(source).mergeMap(func, resFunc).subscribe(o);
+        
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any());
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+}

From 892e27a04c3c48990e8d8023420c8d6fada6ac58 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Fri, 10 Jan 2014 16:42:44 +0100
Subject: [PATCH 197/441] Added event-merger overload

---
 rxjava-core/src/main/java/rx/Observable.java  |  17 ++
 .../java/rx/operators/OperationFlatMap.java   | 162 ++++++++++++++++++
 .../rx/operators/OperationFlatMapTest.java    | 150 ++++++++++++++++
 3 files changed, 329 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index a1227b9ef6..0171917258 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3901,6 +3901,23 @@ public  Observable mergeMapIterable(Func1 the result type
+     * @param onNext function returning a collection to merge for each onNext event of the source
+     * @param onError function returning a collection to merge for an onError event
+     * @param onCompleted function returning a collection to merge for an onCompleted event
+     * @return an Observable that projects the notification of an observable sequence to an observable
+     * sequence and merges the results into one.
+     */
+    public  Observable mergeMap(
+            Func1> onNext, 
+            Func1> onError, 
+            Func0> onCompleted) {
+        return create(OperationFlatMap.flatMap(this, onNext, onError, onCompleted));
+    }
+    
     /**
      * Creates a new Observable by applying a function that you supply to each
      * item emitted by the source Observable, where that function returns an
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
index 20c12993cb..a1a39f5b2b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -22,6 +22,7 @@
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
+import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
@@ -205,4 +206,165 @@ public void onCompleted() {
             }
         };
     }
+    
+    /**
+     * Projects the notification of an observable sequence to an observable
+     * sequence and merges the results into one.
+     */
+    public static  OnSubscribeFunc flatMap(Observable source, 
+            Func1> onNext, 
+            Func1> onError, 
+            Func0> onCompleted) {
+        return new FlatMapTransform(source, onNext, onError, onCompleted);
+    }
+    
+    /**
+     * Projects the notification of an observable sequence to an observable
+     * sequence and merges the results into one.
+     * @param  the source value type
+     * @param  the result value type
+     */
+    private static final class FlatMapTransform implements OnSubscribeFunc {
+        final Observable source;
+        final Func1> onNext;
+        final Func1> onError;
+        final Func0> onCompleted;
+
+        public FlatMapTransform(Observable source, Func1> onNext, Func1> onError, Func0> onCompleted) {
+            this.source = source;
+            this.onNext = onNext;
+            this.onError = onError;
+            this.onCompleted = onCompleted;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+            
+            csub.add(source.subscribe(new SourceObserver(t1, onNext, onError, onCompleted, csub)));
+            
+            return csub;
+        }
+        /**
+         * Observe the source and merge the values.
+         * @param  the source value type
+         * @param  the result value type
+         */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final Func1> onNext;
+            final Func1> onError;
+            final Func0> onCompleted;
+            final CompositeSubscription csub;
+            final AtomicInteger wip;
+            volatile boolean done;
+            final Object guard;
+
+            public SourceObserver(Observer observer, Func1> onNext, Func1> onError, Func0> onCompleted, CompositeSubscription csub) {
+                this.observer = observer;
+                this.onNext = onNext;
+                this.onError = onError;
+                this.onCompleted = onCompleted;
+                this.csub = csub;
+                this.guard = new Object();
+                this.wip = new AtomicInteger(1);
+            }
+
+            @Override
+            public void onNext(T args) {
+                Observable o;
+                try {
+                    o = onNext.call(args);
+                } catch (Throwable t) {
+                    synchronized (guard) {
+                        observer.onError(t);
+                    }
+                    csub.unsubscribe();
+                    return;
+                }
+                subscribeInner(o);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                Observable o;
+                try {
+                    o = onError.call(e);
+                } catch (Throwable t) {
+                    synchronized (guard) {
+                        observer.onError(t);
+                    }
+                    csub.unsubscribe();
+                    return;
+                }
+                subscribeInner(o);
+                done = true;
+                finish();
+            }
+
+            @Override
+            public void onCompleted() {
+                Observable o;
+                try {
+                    o = onCompleted.call();
+                } catch (Throwable t) {
+                    synchronized (guard) {
+                        observer.onError(t);
+                    }
+                    csub.unsubscribe();
+                    return;
+                }
+                subscribeInner(o);
+                done = true;
+                finish();
+            }
+            
+            void subscribeInner(Observable o) {
+                SerialSubscription ssub = new SerialSubscription();
+                wip.incrementAndGet();
+                csub.add(ssub);
+                
+                ssub.set(o.subscribe(new CollectionObserver(this, ssub)));
+            }
+            void finish() {
+                if (wip.decrementAndGet() == 0) {
+                    synchronized (guard) {
+                        observer.onCompleted();
+                    }
+                    csub.unsubscribe();
+                }
+            }
+        }
+        /** Observes the collections. */
+        private static final class CollectionObserver implements Observer {
+            final SourceObserver parent;
+            final Subscription cancel;
+
+            public CollectionObserver(SourceObserver parent, Subscription cancel) {
+                this.parent = parent;
+                this.cancel = cancel;
+            }
+
+            @Override
+            public void onNext(R args) {
+                synchronized (parent.guard) {
+                    parent.observer.onNext(args);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (parent.guard) {
+                    parent.observer.onError(e);
+                }
+                parent.csub.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                parent.csub.remove(cancel);
+                parent.finish();
+            }
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
index 9c3afd73f7..f081f0f8e8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
@@ -21,6 +21,7 @@
 import static org.mockito.Mockito.*;
 import rx.Observable;
 import rx.Observer;
+import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
@@ -142,4 +143,153 @@ public Integer call(Integer t1, Integer t2) {
         verify(o, never()).onNext(any());
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
+     Func1 just(final R value) {
+        return new Func1() {
+
+            @Override
+            public R call(T t1) {
+                return value;
+            }
+        };
+    }
+     Func0 just0(final R value) {
+        return new Func0() {
+
+            @Override
+            public R call() {
+                return value;
+            }
+        };
+    }
+    @Test
+    public void testFlatMapTransformsNormal() {
+        Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.from(Arrays.asList(10, 20, 30));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(just(onNext), just(onError), just0(onCompleted)).subscribe(o);
+        
+        verify(o, times(3)).onNext(1);
+        verify(o, times(3)).onNext(2);
+        verify(o, times(3)).onNext(3);
+        verify(o).onNext(4);
+        verify(o).onCompleted();
+        
+        verify(o, never()).onNext(5);
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testFlatMapTransformsException() {
+        Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.concat(
+                Observable.from(Arrays.asList(10, 20, 30))
+                , Observable.error(new RuntimeException("Forced failure!"))
+                );
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(just(onNext), just(onError), just0(onCompleted)).subscribe(o);
+        
+        verify(o, times(3)).onNext(1);
+        verify(o, times(3)).onNext(2);
+        verify(o, times(3)).onNext(3);
+        verify(o).onNext(5);
+        verify(o).onCompleted();
+        verify(o, never()).onNext(4);
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+     Func0 funcThrow0(R r) {
+        return new Func0() {
+            @Override
+            public R call() {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+    }
+     Func1 funcThrow(T t, R r) {
+        return new Func1() {
+            @Override
+            public R call(T t) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+    }
+    @Test
+    public void testFlatMapTransformsOnNextFuncThrows() {
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.from(Arrays.asList(10, 20, 30));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(funcThrow(1, onError), just(onError), just0(onCompleted)).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test
+    public void testFlatMapTransformsOnErrorFuncThrows() {
+        Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.error(new OperationReduceTest.CustomException());
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(just(onNext), funcThrow((Throwable)null, onError), just0(onCompleted)).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    
+    @Test
+    public void testFlatMapTransformsOnCompletedFuncThrows() {
+        Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.from(Arrays.asList());
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
+    @Test 
+    public void testFlatMapTransformsMergeException() {
+        Observable onNext = Observable.error(new OperationReduceTest.CustomException());
+        Observable onCompleted = Observable.from(Arrays.asList(4));
+        Observable onError = Observable.from(Arrays.asList(5));
+        
+        Observable source = Observable.from(Arrays.asList(10, 20, 30));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+    }
 }

From 900dca88e5ccbfeaa3d6ce63631e2ca737455782 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 11 Jan 2014 09:27:52 +0100
Subject: [PATCH 198/441] Publish and PublishLast overloads

---
 rxjava-core/src/main/java/rx/Observable.java | 79 +++++++++++++++++++-
 1 file changed, 78 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..780ab8ed0c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -107,11 +107,11 @@
 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.schedulers.Schedulers;
 import rx.subjects.AsyncSubject;
+import rx.subjects.BehaviorSubject;
 import rx.subjects.PublishSubject;
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
@@ -5226,6 +5226,59 @@ public ConnectableObservable publish() {
         return OperationMulticast.multicast(this, PublishSubject. create());
     }
 
+    /**
+     * Create a connectable observable sequence that shares a single
+     * subscription to the underlying sequence and starts with initialValue.
+     * @param initialValue the initial value of the underlying BehaviorSubject
+     * @return a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
+     */
+    public ConnectableObservable publish(T initialValue) {
+        return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
+    }
+    
+    /**
+     * Create an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence.
+     * @param  the result type
+     * @param selector function which can use the multicasted source
+     * sequence as many times as needed, without causing multiple
+     * subscriptions to the source sequence. Subscribers to the given
+     * source will receive all notifications of the source from the time
+     * of the subscription on.
+     * @return an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence.
+     */
+    public  Observable publish(Func1, Observable> selector) {
+        return multicast(new Func0>() {
+            @Override
+            public Subject call() {
+                return PublishSubject.create();
+            }
+        }, selector);
+    }
+    
+    /**
+     * Create an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
+     * @param  the result type
+     * @param selector function which can use the multicasted source
+     * sequence as many times as needed, without causing multiple
+     * subscriptions to the source sequence. Subscribers to the given
+     * source will receive all notifications of the source from the time
+     * of the subscription on
+     * @param initialValue the initial value of the underlying BehaviorSubject
+     * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue
+     */
+    public  Observable publish(Func1, Observable> selector, final T initialValue) {
+        return multicast(new Func0>() {
+            @Override
+            public Subject call() {
+                return BehaviorSubject.create(initialValue);
+            }
+        }, selector);
+    }
+    
     /**
      * Returns a {@link ConnectableObservable} that emits only the last item
      * emitted by the source Observable.
@@ -5238,6 +5291,30 @@ public ConnectableObservable publish() {
     public ConnectableObservable publishLast() {
         return OperationMulticast.multicast(this, AsyncSubject. create());
     }
+    
+    /**
+     * Create an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence containing only the last
+     * notification.
+     * @param  the result type
+     * @param selector function which can use the multicasted source
+     * sequence as many times as needed, without causing multiple
+     * subscriptions to the source sequence. Subscribers to the given
+     * source will only receive the last notification of the source
+     * @return an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single 
+     * subscription to the underlying sequence containing only the last
+     * notification.
+     */
+    public  Observable publishLast(Func1, Observable> selector) {
+        return multicast(new Func0>() {
+            @Override
+            public Subject call() {
+                return AsyncSubject.create();
+            }
+        }, selector);
+    }
 
     /**
      * Synonymous with reduce().

From 0ad8980fdafe0febeeb9012ae1f04c97d694ecd3 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 11 Jan 2014 09:50:11 +0100
Subject: [PATCH 199/441] Added variance to selector functions

---
 rxjava-core/src/main/java/rx/Observable.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 780ab8ed0c..7b863a03ac 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5250,7 +5250,7 @@ public ConnectableObservable publish(T initialValue) {
      * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence.
      */
-    public  Observable publish(Func1, Observable> selector) {
+    public  Observable publish(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
             @Override
             public Subject call() {
@@ -5270,7 +5270,7 @@ public Subject call() {
      * @param initialValue the initial value of the underlying BehaviorSubject
      * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue
      */
-    public  Observable publish(Func1, Observable> selector, final T initialValue) {
+    public  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
         return multicast(new Func0>() {
             @Override
             public Subject call() {
@@ -5307,7 +5307,7 @@ public ConnectableObservable publishLast() {
      * subscription to the underlying sequence containing only the last
      * notification.
      */
-    public  Observable publishLast(Func1, Observable> selector) {
+    public  Observable publishLast(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
             @Override
             public Subject call() {

From 27b81efee2d19df15bb8e23e06336e2180994f1e Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 11 Jan 2014 10:38:42 +0100
Subject: [PATCH 200/441] Debounce with selector

---
 rxjava-core/src/main/java/rx/Observable.java  |  14 ++
 .../java/rx/operators/OperationDebounce.java  | 160 ++++++++++++++++++
 .../rx/operators/OperationDebounceTest.java   |  87 +++++++++-
 3 files changed, 260 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..00fcfba6f3 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2266,6 +2266,20 @@ public Observable debounce(long timeout, TimeUnit unit) {
         return create(OperationDebounce.debounce(this, timeout, unit));
     }
 
+    /**
+     * Create an Observable that ignores elements from this observable
+     * sequence which are followed by another value within a computed
+     * debounce duration.
+     * @param  the debounce value type (ignored)
+     * @param debounceSelector function to retrieve a sequence indicating the throttle duration for each given element.
+     * @return an Observable that ignores elements from this observable
+     * sequence which are followed by another value within a computed
+     * debounce duration
+     */
+    public  Observable debounce(Func1> debounceSelector) {
+        return create(OperationDebounce.debounceSelector(this, debounceSelector));
+    }
+    
     /**
      * Drops items emitted by an Observable that are followed by newer items
      * before a timeout value expires. The timer resets on each emission.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 2e312fee31..99d3a47a38 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -24,6 +24,8 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.SerialSubscription;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
 
@@ -151,4 +153,162 @@ public void call() {
             }
         }
     }
+    
+    /**
+     * Delay the emission via another observable if no new source appears in the meantime.
+     */
+    public static  OnSubscribeFunc debounceSelector(
+            Observable source,
+            Func1> debounceSelector) {
+        return new DebounceSelector(source, debounceSelector);
+    }
+    
+    /**
+     * Delay the emission via another observable if no new source appears in the meantime.
+     */
+    private static final class DebounceSelector implements OnSubscribeFunc {
+        final Observable source;
+        final Func1> debounceSelector;
+
+        public DebounceSelector(Observable source, Func1> debounceSelector) {
+            this.source = source;
+            this.debounceSelector = debounceSelector;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+            
+            csub.add(source.subscribe(new SourceObserver(t1, debounceSelector, csub)));
+            
+            return csub;
+        }
+        
+        /** Observe the source. */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final Func1> debounceSelector;
+            final CompositeSubscription cancel;
+            final SerialSubscription ssub = new SerialSubscription();
+            long index;
+            T value;
+            boolean hasValue;
+            final Object guard;
+            
+            public SourceObserver(
+                    Observer observer, 
+                    Func1> debounceSelector, 
+                    CompositeSubscription cancel) {
+                this.observer = observer;
+                this.debounceSelector = debounceSelector;
+                this.cancel = cancel;
+                this.cancel.add(ssub);
+                this.guard = new Object();
+            }
+
+            @Override
+            public void onNext(T args) {
+                Observable o;
+                try {
+                    o = debounceSelector.call(args);
+                } catch (Throwable t) {
+                    synchronized (guard) {
+                        observer.onError(t);
+                    }
+                    cancel.unsubscribe();
+                    return;
+                }
+                long currentIndex;
+                synchronized (guard) {
+                    hasValue = true;
+                    value = args;
+                    currentIndex = ++index;
+                }
+                
+                SerialSubscription osub = new SerialSubscription();
+                ssub.set(osub);
+
+                osub.set(o.subscribe(new DebounceObserver(this, osub, args, currentIndex)));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                ssub.unsubscribe();
+                try {
+                    synchronized (guard) {
+                        observer.onError(e);
+                        hasValue = false;
+                        value = null;
+                        index++;
+                    }
+                } finally {
+                    cancel.unsubscribe();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                ssub.unsubscribe();
+                try {
+                    synchronized (guard) {
+                        if (hasValue) {
+                            try {
+                                observer.onNext(value);
+                            } catch (Throwable t) {
+                                observer.onError(t);
+                                return;
+                            }
+                        }
+                        observer.onCompleted();
+                        hasValue = false;
+                        value = null;
+                        index++;
+                    }
+                } finally {
+                    cancel.unsubscribe();
+                }
+            }
+        }
+        /**
+         * The debounce observer.
+         */
+        private static final class DebounceObserver implements Observer {
+            final SourceObserver parent;
+            final Subscription cancel;
+            final T value;
+            final long currentIndex;
+
+            public DebounceObserver(SourceObserver parent, Subscription cancel, T value, long currentIndex) {
+                this.parent = parent;
+                this.cancel = cancel;
+                this.value = value;
+                this.currentIndex = currentIndex;
+            }
+
+            @Override
+            public void onNext(U args) {
+                onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronized (parent.guard) {
+                    parent.observer.onError(e);
+                }
+                parent.cancel.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                synchronized (parent.guard) {
+                    if (parent.hasValue && parent.index == currentIndex) {
+                        parent.observer.onNext(value);
+                    }
+                    parent.hasValue = false;
+                }
+                cancel.unsubscribe();
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index 9779239f95..02f5ccde0a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -15,7 +15,6 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
@@ -28,8 +27,10 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Func1;
 
 public class OperationDebounceTest {
 
@@ -158,4 +159,88 @@ public void call() {
     @SuppressWarnings("serial")
     private class TestException extends Exception {
     }
+    
+    @Test
+    public void debounceSelectorNormal1() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject debouncer = PublishSubject.create();
+        Func1> debounceSel = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return debouncer;
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.debounce(debounceSel).subscribe(o);
+        
+        source.onNext(1);
+        debouncer.onNext(1);
+        
+        source.onNext(2);
+        source.onNext(3);
+        source.onNext(4);
+
+        debouncer.onNext(2);
+        
+        source.onNext(5);
+        source.onCompleted();
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(4);
+        inOrder.verify(o).onNext(5);
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void debounceSelectorFuncThrows() {
+        PublishSubject source = PublishSubject.create();
+        Func1> debounceSel = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.debounce(debounceSel).subscribe(o);
+        
+        source.onNext(1);
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    
+    @Test
+    public void debounceSelectorObservableThrows() {
+        PublishSubject source = PublishSubject.create();
+        Func1> debounceSel = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return Observable.error(new OperationReduceTest.CustomException());
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.debounce(debounceSel).subscribe(o);
+        
+        source.onNext(1);
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
 }

From 34c563858e028d3fe7a2d3cac5a0585fac61f3a9 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 11 Jan 2014 11:57:16 +0100
Subject: [PATCH 201/441] Timeout with selector overloads

---
 rxjava-core/src/main/java/rx/Observable.java  |  80 ++++++
 .../java/rx/operators/OperationTimeout.java   | 158 ++++++++++++
 .../rx/operators/OperationTimeoutTest.java    | 236 ++++++++++++++++++
 3 files changed, 474 insertions(+)
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..6319767d4d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6691,6 +6691,86 @@ public Observable timeout(long timeout, TimeUnit timeUnit, Observable
+     * The arrival of the first source item is not timed out.
+     * @param  the timeout value type (ignored)
+     * @param timeoutSelector function that returns an observable for each source item
+     * which determines the timeout window for the subsequent source item
+     * @return an observable which completes if a source item doesn't arrive after the 
+     * previous one in the time window specified by the per-item observable.
+     */
+    public  Observable timeout(Func1> timeoutSelector) {
+        return timeout(timeoutSelector, Observable.empty());
+    }
+
+    /**
+     * Create an observable which switches to the other Observable if a source 
+     * item doesn't arrive after the 
+     * previous one in the time window specified by the per-item observable.
+     * 
    
+     * The arrival of the first source item is not timed out.
+     * @param  the timeout value type (ignored)
+     * @param timeoutSelector function that returns an observable for each source item
+     * which determines the timeout window for the subsequent source item
+     * @param other the other observable to switch to if the source times out
+     * @return an observable which switches to the other Observable if a source 
+     * item doesn't arrive after the 
+     * previous one in the time window specified by the per-item observable
+     */
+    public  Observable timeout(Func1> timeoutSelector, Observable other) {
+        if (other == null) {
+            throw new NullPointerException("other");
+        }
+        return create(OperationTimeout.timeoutSelector(this, null, timeoutSelector, other));
+    }
+
+    /**
+     * Create an Observable which completes if either the first item or any subsequent item
+     * doesn't arrive within the time window specified by the timeout selectors' Observable.
+     * @param  the first timeout value type (ignored)
+     * @param  the subsequent timeout value type (ignored)
+     * @param firstTimeoutSelector function that returns an observable which determines
+     * the timeout window for the first source item
+     * @param timeoutSelector function that returns an observable for each source item
+     * which determines the timeout window for the subsequent source item
+     * @return an Observable which completes if either the first item or any subsequent item
+     * doesn't arrive within the time window specified by the timeout selectors' Observable.
+     */
+    public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
+        if (firstTimeoutSelector == null) {
+            throw new NullPointerException("firstTimeoutSelector");
+        }
+        return timeout(firstTimeoutSelector, timeoutSelector, Observable.empty());
+    }
+
+    /**
+     * Create an Observable which switches to another Observable
+     * if either the first item or any subsequent item
+     * doesn't arrive within the time window specified by the timeout selectors' Observable.
+     * @param  the first timeout value type (ignored)
+     * @param  the subsequent timeout value type (ignored)
+     * @param firstTimeoutSelector function that returns an observable which determines
+     * the timeout window for the first source item
+     * @param timeoutSelector function that returns an observable for each source item
+     * which determines the timeout window for the subsequent source item
+     * @param other the other observable to switch to if the source times out
+     * @return an Observable which switches to another Observable
+     * if either the first item or any subsequent item
+     * doesn't arrive within the time window specified by the timeout selectors' Observable
+     */
+    public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
+        if (firstTimeoutSelector == null) {
+            throw new NullPointerException("firstTimeoutSelector");
+        }
+        if (other == null) {
+            throw new NullPointerException("other");
+        }
+        return create(OperationTimeout.timeoutSelector(this, firstTimeoutSelector, timeoutSelector, other));
+    }
+
     /**
      * Records the time interval between consecutive items emitted by an
      * Observable.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
index 8f4c5b4b0e..f93bfd2eec 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
@@ -28,8 +28,10 @@
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
+import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Func0;
+import rx.util.functions.Func1;
 
 /**
  * Applies a timeout policy for each element in the observable sequence, using
@@ -154,4 +156,160 @@ public void onCompleted() {
             return composite;
         }
     }
+    
+    /** Timeout using a per-item observable sequence. */
+    public static  OnSubscribeFunc timeoutSelector(Observable source, Func0> firstValueTimeout, Func1> valueTimeout, Observable other) {
+        return new TimeoutSelector(source, firstValueTimeout, valueTimeout, other);
+    }
+    
+    /** Timeout using a per-item observable sequence. */
+    private static final class TimeoutSelector implements OnSubscribeFunc {
+        final Observable source;
+        final Func0> firstValueTimeout;
+        final Func1> valueTimeout;
+        final Observable other;
+
+        public TimeoutSelector(Observable source, Func0> firstValueTimeout, Func1> valueTimeout, Observable other) {
+            this.source = source;
+            this.firstValueTimeout = firstValueTimeout;
+            this.valueTimeout = valueTimeout;
+            this.other = other;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            CompositeSubscription csub = new CompositeSubscription();
+
+            SourceObserver so = new SourceObserver(t1, valueTimeout, other, csub);
+            if (firstValueTimeout != null) {
+                Observable o;
+                try {
+                    o = firstValueTimeout.call();
+                } catch (Throwable t) {
+                    t1.onError(t);
+                    return Subscriptions.empty();
+                }
+                
+                csub.add(o.subscribe(new TimeoutObserver(so)));
+            }
+            csub.add(source.subscribe(so));
+            return csub;
+        }
+        
+        /** Observe the source. */
+        private static final class SourceObserver implements Observer, TimeoutCallback {
+            final Observer observer;
+            final Func1> valueTimeout;
+            final Observable other;
+            final CompositeSubscription cancel;
+            final Object guard;
+            boolean done;
+            final SerialSubscription tsub;
+            final TimeoutObserver to;
+
+            public SourceObserver(Observer observer, Func1> valueTimeout, Observable other, CompositeSubscription cancel) {
+                this.observer = observer;
+                this.valueTimeout = valueTimeout;
+                this.other = other;
+                this.cancel = cancel;
+                this.guard = new Object();
+                this.tsub = new SerialSubscription();
+                this.cancel.add(tsub);
+                this.to = new TimeoutObserver(this);
+            }
+
+            @Override
+            public void onNext(T args) {
+                tsub.set(Subscriptions.empty());
+                
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    observer.onNext(args);
+                }
+                
+                Observable o;
+                try {
+                    o = valueTimeout.call(args);
+                } catch (Throwable t) {
+                    onError(t);
+                    return;
+                }
+                
+                SerialSubscription osub = new SerialSubscription();
+                tsub.set(osub);
+                
+                osub.set(o.subscribe(to));
+            }
+            @Override
+            public void onError(Throwable e) {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    observer.onError(e);
+                }
+                cancel.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                synchronized (guard) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    observer.onCompleted();
+                }
+                cancel.unsubscribe();
+            }
+            @Override
+            public void timeout() {
+                if (other != null) {
+                    synchronized (guard) {
+                        if (done) {
+                            return;
+                        }
+                        done = true;
+                    }
+                    cancel.clear();
+                    cancel.add(other.subscribe(observer));
+                } else {
+                    onCompleted();
+                }
+            }
+        }
+        
+        /** The timeout callback. */
+        private interface TimeoutCallback {
+            void timeout();
+            void onError(Throwable t);
+        }
+        
+        /** Observe the timeout. */
+        private static final class TimeoutObserver implements Observer {
+            final TimeoutCallback parent;
+
+            public TimeoutObserver(TimeoutCallback parent) {
+                this.parent = parent;
+            }
+            
+            @Override
+            public void onNext(V args) {
+                parent.timeout();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                parent.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                parent.timeout();
+            }
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
new file mode 100644
index 0000000000..833d2060ec
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
@@ -0,0 +1,236 @@
+/**
+ * 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 java.util.Arrays;
+import org.junit.Test;
+import org.mockito.InOrder;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.subjects.PublishSubject;
+import rx.util.functions.Func0;
+import rx.util.functions.Func1;
+
+public class OperationTimeoutTest {
+    @Test
+    public void testTimeoutSelectorNormal1() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return timeout;
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return timeout;
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        timeout.onNext(1);
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o).onNext(100);
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    
+    @Test
+    public void testTimeoutSelectorTimeoutFirst() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return timeout;
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return timeout;
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        timeout.onNext(1);
+        
+        inOrder.verify(o).onNext(100);
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    
+    @Test
+    public void testTimeoutSelectorFirstThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return timeout;
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        
+    }
+    @Test
+    public void testTimeoutSelectorSubsequentThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return timeout;
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        source.onNext(1);
+
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onCompleted();
+        
+    }
+    
+    @Test
+    public void testTimeoutSelectorFirstObservableThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return timeout;
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return Observable.error(new OperationReduceTest.CustomException());
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        
+    }
+    @Test
+    public void testTimeoutSelectorSubsequentObservableThrows() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+        
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return Observable.error(new OperationReduceTest.CustomException());
+            }
+        };
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return timeout;
+            }
+        };
+        
+        Observable other = Observable.from(Arrays.asList(100));
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
+        
+        source.onNext(1);
+
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onCompleted();
+        
+    }
+}

From 25910ee4fedd6b6e611d406b0999589b43923978 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Sat, 11 Jan 2014 13:18:53 +0100
Subject: [PATCH 202/441] Zip with iterable, removed old aggregator version and
 updated tests

---
 rxjava-core/src/main/java/rx/Observable.java  |  34 ++
 .../main/java/rx/operators/OperationZip.java  | 319 ++++------
 .../java/rx/operators/OperationZipTest.java   | 564 ++++++++++++------
 3 files changed, 524 insertions(+), 393 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2ac2fb7b5d..eee85509cf 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2626,6 +2626,40 @@ public static  Observable zip(Observable o1, Observa
         return create(OperationZip.zip(o1, o2, zipFunction));
     }
 
+    /**
+     * Return an Observable that pairs up values from this Observable and the other
+     * Observable and applies a function.
+     * @param  the other value type
+     * @param  the result type
+     * @param other the other Observable sequence
+     * @param zipFunction the function that combines the pairs of items from both
+     * observables and returns a new value
+     * @return an Observable that pairs up values from this Observable and the other
+     * Observable and applies a function.
+     */
+    public  Observable zip(Observable other, Func2 zipFunction) {
+        return zip(this, other, zipFunction);
+    }
+
+    /**
+     * Return an Observable that pairs up values from this Observable and an
+     * Iterable sequence and applies a function.
+     * 
    
+     * Note that the other Iterable is evaluated as items appear from this
+     * Observable and is not pre-consumed, allowing zipping infinite streams
+     * on either side.
+     * @param  the other value type
+     * @param  the result type
+     * @param other the other Iterable sequence
+     * @param zipFunction the function that combines the pairs of items of
+     * this Observable and the Iterable
+     * @return an Observable that pairs up values from this Observable and an
+     * Iterable sequence and applies a function.
+     */
+    public  Observable zip(Iterable other, Func2 zipFunction) {
+        return create(OperationZip.zipIterable(this, other, zipFunction));
+    }
+
     /**
      * Returns an Observable that emits the results of a function of your
      * choosing applied to combinations of three items emitted, in sequence, by
diff --git a/rxjava-core/src/main/java/rx/operators/OperationZip.java b/rxjava-core/src/main/java/rx/operators/OperationZip.java
index 6ecbb87e49..093eeb74d0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationZip.java
@@ -17,12 +17,10 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
@@ -32,6 +30,7 @@
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
+import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func2;
 import rx.util.functions.Func3;
 import rx.util.functions.Func4;
@@ -108,211 +107,6 @@ public static  OnSubscribeFunc zip(Iterable> ws, f
         return a;
     }
     
-    /*
-    * ThreadSafe
-    */
-    /* package accessible for unit tests */static class ZipObserver implements Observer {
-        final Observable w;
-        final Aggregator a;
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-        private final AtomicBoolean subscribed = new AtomicBoolean(false);
-        
-        public ZipObserver(Aggregator a, Observable w) {
-            this.a = a;
-            this.w = w;
-        }
-        
-        public void startWatching() {
-            if (subscribed.compareAndSet(false, true)) {
-                // only subscribe once even if called more than once
-                subscription.wrap(w.subscribe(this));
-            }
-        }
-        
-        @Override
-        public void onCompleted() {
-            a.complete(this);
-        }
-        
-        @Override
-        public void onError(Throwable e) {
-            a.error(this, e);
-        }
-        
-        @Override
-        public void onNext(T args) {
-            try {
-                a.next(this, args);
-            } catch (Throwable e) {
-                onError(e);
-            }
-        }
-    }
-    
-    /**
-     * Receive notifications from each of the Observables we are reducing and execute the zipFunction whenever we have received events from all Observables.
-     *
-     * This class is thread-safe.
-     *
-     * @param 
-     */
-    /* package accessible for unit tests */static class Aggregator implements OnSubscribeFunc {
-        
-        private volatile SynchronizedObserver observer;
-        private final FuncN zipFunction;
-        private final AtomicBoolean started = new AtomicBoolean(false);
-        private final AtomicBoolean running = new AtomicBoolean(true);
-        private final ConcurrentHashMap, Boolean> completed = new ConcurrentHashMap, Boolean>();
-        
-        /* we use ConcurrentHashMap despite synchronization of methods because stop() does NOT use synchronization and this map is used by it and can be called by other threads */
-        private ConcurrentHashMap, ConcurrentLinkedQueue> receivedValuesPerObserver = new ConcurrentHashMap, ConcurrentLinkedQueue>();
-        /* we use a ConcurrentLinkedQueue to retain ordering (I'd like to just use a ConcurrentLinkedHashMap for 'receivedValuesPerObserver' but that doesn't exist in standard java */
-        private ConcurrentLinkedQueue> observers = new ConcurrentLinkedQueue>();
-        
-        public Aggregator(FuncN zipFunction) {
-            this.zipFunction = zipFunction;
-        }
-        
-        /**
-         * Receive notification of a Observer starting (meaning we should require it for aggregation)
-         *
-         * Thread Safety => Invoke ONLY from the static factory methods at top of this class which are always an atomic execution by a single thread.
-         *
-         * @param w
-         */
-        void addObserver(ZipObserver w) {
-            // initialize this ZipObserver
-            observers.add(w);
-            receivedValuesPerObserver.put(w, new ConcurrentLinkedQueue());
-        }
-        
-        /**
-         * Receive notification of a Observer completing its iterations.
-         *
-         * @param w
-         */
-        void complete(ZipObserver w) {
-            // store that this ZipObserver is completed
-            completed.put(w, Boolean.TRUE);
-            // if all ZipObservers are completed, we mark the whole thing as completed
-            if (completed.size() == observers.size()) {
-                if (running.compareAndSet(true, false)) {
-                    // this thread succeeded in setting running=false so let's propagate the completion
-                    // mark ourselves as done
-                    observer.onCompleted();
-                }
-            }
-        }
-        
-        /**
-         * Receive error for a Observer. Throw the error up the chain and stop processing.
-         *
-         * @param w
-         */
-        void error(ZipObserver w, Throwable e) {
-            if (running.compareAndSet(true, false)) {
-                // this thread succeeded in setting running=false so let's propagate the error
-                observer.onError(e);
-                /* since we receive an error we want to tell everyone to stop */
-                stop();
-            }
-        }
-        
-        /**
-         * Receive the next value from a Observer.
-         * 
    
-         * If we have received values from all Observers, trigger the zip function, otherwise store the value and keep waiting.
-         *
-         * @param w
-         * @param arg
-         */
-        void next(ZipObserver w, Object arg) {
-            if (observer == null) {
-                throw new RuntimeException("This shouldn't be running if a Observer isn't registered");
-            }
-            
-            /* if we've been 'unsubscribed' don't process anything further even if the things we're watching keep sending (likely because they are not responding to the unsubscribe call) */
-            if (!running.get()) {
-                return;
-            }
-            
-            // store the value we received and below we'll decide if we are to send it to the Observer
-            receivedValuesPerObserver.get(w).add(arg);
-            
-            // define here so the variable is out of the synchronized scope
-            Object[] argsToZip = new Object[observers.size()];
-            
-            /* we have to synchronize here despite using concurrent data structures because the compound logic here must all be done atomically */
-            synchronized (this) {
-                // if all ZipObservers in 'receivedValues' map have a value, invoke the zipFunction
-                for (ZipObserver rw : receivedValuesPerObserver.keySet()) {
-                    if (receivedValuesPerObserver.get(rw).peek() == null) {
-                        // we have a null meaning the queues aren't all populated so won't do anything
-                        return;
-                    }
-                }
-                // if we get to here this means all the queues have data
-                int i = 0;
-                for (ZipObserver rw : observers) {
-                    argsToZip[i++] = receivedValuesPerObserver.get(rw).remove();
-                }
-            }
-            // if we did not return above from the synchronized block we can now invoke the zipFunction with all of the args
-            // we do this outside the synchronized block as it is now safe to call this concurrently and don't need to block other threads from calling
-            // this 'next' method while another thread finishes calling this zipFunction
-            observer.onNext(zipFunction.call(argsToZip));
-        }
-        
-        @Override
-        public Subscription onSubscribe(Observer observer) {
-            if (started.compareAndSet(false, true)) {
-                SafeObservableSubscription subscription = new SafeObservableSubscription();
-                this.observer = new SynchronizedObserver(observer, subscription);
-                /* start the Observers */
-                for (ZipObserver rw : observers) {
-                    rw.startWatching();
-                }
-                
-                return subscription.wrap(new Subscription() {
-                    
-                    @Override
-                    public void unsubscribe() {
-                        stop();
-                    }
-                    
-                });
-            } else {
-                /* a Observer already has subscribed so blow up */
-                throw new IllegalStateException("Only one Observer can subscribe to this Observable.");
-            }
-        }
-        
-        /*
-        * Do NOT synchronize this because it gets called via unsubscribe which can occur on other threads
-        * and result in deadlocks. (http://jira/browse/API-4060)
-        *
-        * AtomicObservableSubscription uses compareAndSet instead of locking to avoid deadlocks but ensure single-execution.
-        *
-        * We do the same in the implementation of this method.
-        *
-        * ThreadSafety of this method is provided by:
-        * - AtomicBoolean[running].compareAndSet
-        * - ConcurrentLinkedQueue[Observers]
-        * - ZipObserver.subscription being an AtomicObservableSubscription
-        */
-        private void stop() {
-            /* tell ourselves to stop processing onNext events by setting running=false */
-            if (running.compareAndSet(true, false)) {
-                /* propogate to all Observers to unsubscribe if this thread succeeded in setting running=false */
-                for (ZipObserver o : observers) {
-                    if (o.subscription != null) {
-                        o.subscription.unsubscribe();
-                    }
-                }
-            }
-        }
-        
-    }
     /**
      * Merges the values across multiple sources and applies the selector
      * function.
@@ -324,7 +118,7 @@ private void stop() {
      * @param  the common element type
      * @param  the result element type
      */
-    public static class ManyObservables implements OnSubscribeFunc {
+    private static final class ManyObservables implements OnSubscribeFunc {
         /** */
         protected final Iterable> sources;
         /** */
@@ -384,7 +178,7 @@ public void onNext(List value) {
          * @author akarnokd, 2013.01.14.
          * @param  the element type
          */
-        public static class ItemObserver implements Observer, Subscription {
+        private static final class ItemObserver implements Observer, Subscription {
             /** Reader-writer lock. */
             protected  final ReadWriteLock rwLock;
             /** The queue. */
@@ -528,4 +322,109 @@ public void unsubscribe() {
             
         }
     }
+    
+    /**
+     * Zips an Observable and an iterable sequence and applies
+     * a function to the pair of values.
+     */
+    public static  OnSubscribeFunc zipIterable(Observable source, Iterable other, Func2 zipFunction) {
+        return new ZipIterable(source, other, zipFunction);
+    }
+    
+    /**
+     * Zips an Observable and an iterable sequence and applies
+     * a function to the pair of values.
+     */
+    private static final class ZipIterable implements OnSubscribeFunc {
+        final Observable source;
+        final Iterable other;
+        final Func2 zipFunction;
+
+        public ZipIterable(Observable source, Iterable other, Func2 zipFunction) {
+            this.source = source;
+            this.other = other;
+            this.zipFunction = zipFunction;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            
+            Iterator it;
+            boolean first;
+            try {
+                it = other.iterator();
+                first = it.hasNext();
+            } catch (Throwable t) {
+                t1.onError(t);
+                return Subscriptions.empty();
+            }
+
+            
+            if (!first) {
+                t1.onCompleted();
+                return Subscriptions.empty();
+            }
+            
+            SerialSubscription ssub = new SerialSubscription();
+            
+            ssub.set(source.subscribe(new SourceObserver(t1, it, zipFunction, ssub)));
+            
+            return ssub;
+        }
+        /** Observe the source. */
+        private static final class SourceObserver implements Observer {
+            final Observer observer;
+            final Iterator other; 
+            final Func2 zipFunction;
+            final Subscription cancel;
+
+            public SourceObserver(Observer observer, Iterator other,
+                    Func2 zipFunction, Subscription cancel) {
+                this.observer = observer;
+                this.other = other;
+                this.zipFunction = zipFunction;
+                this.cancel = cancel;
+            }
+
+            @Override
+            public void onNext(T args) {
+                U u = other.next();
+                
+                R r;
+                try {
+                    r = zipFunction.call(args, u);
+                } catch (Throwable t) {
+                    onError(t);
+                    return;
+                }
+                
+                observer.onNext(r);
+                
+                boolean has;
+                try {
+                    has = other.hasNext();
+                } catch (Throwable t) {
+                    onError(t);
+                    return;
+                }
+                
+                if (!has) {
+                    onCompleted();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+                cancel.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                observer.onCompleted();
+                cancel.unsubscribe();
+            }
+            
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTest.java b/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
index 3f4ac10a55..6bd8b36b62 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
@@ -26,6 +26,8 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -34,8 +36,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.operators.OperationZip.Aggregator;
-import rx.operators.OperationZip.ZipObserver;
+import rx.operators.OperationReduceTest.CustomException;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func2;
@@ -118,10 +119,10 @@ public void testZippingDifferentLengthObservableSequences1() {
         w3.observer.onCompleted();
 
         /* we should have been called 1 time on the Observer */
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w).onNext("1a2a3a");
+        InOrder io = inOrder(w);
+        io.verify(w).onNext("1a2a3a");
 
-        inOrder.verify(w, times(1)).onCompleted();
+        io.verify(w, times(1)).onCompleted();
     }
 
     @Test
@@ -152,13 +153,30 @@ public void testZippingDifferentLengthObservableSequences2() {
         w3.observer.onCompleted();
 
         /* we should have been called 1 time on the Observer */
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w).onNext("1a2a3a");
+        InOrder io = inOrder(w);
+        io.verify(w).onNext("1a2a3a");
 
-        inOrder.verify(w, times(1)).onCompleted();
+        io.verify(w, times(1)).onCompleted();
 
     }
 
+    
+    Func2 zipr2 = new Func2() {
+
+        @Override
+        public String call(Object t1, Object t2) {
+            return "" + t1 + t2;
+        }
+
+    };
+    Func3 zipr3 = new Func3() {
+
+        @Override
+        public String call(Object t1, Object t2, Object t3) {
+            return "" + t1 + t2 + t3;
+        }
+
+    };
     /**
      * Testing internal private logic due to the complexity so I want to use TDD to test as a I build it rather than relying purely on the overall functionality expected by the public methods.
      */
@@ -166,25 +184,16 @@ public void testZippingDifferentLengthObservableSequences2() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorSimple() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, "world");
+        r1.onNext("hello");
+        r2.onNext("world");
 
         InOrder inOrder = inOrder(aObserver);
 
@@ -192,15 +201,15 @@ public void testAggregatorSimple() {
         verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, times(1)).onNext("helloworld");
 
-        a.next(r1, "hello ");
-        a.next(r2, "again");
+        r1.onNext("hello ");
+        r2.onNext("again");
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, times(1)).onNext("hello again");
 
-        a.complete(r1);
-        a.complete(r2);
+        r1.onCompleted();
+        r2.onCompleted();
 
         inOrder.verify(aObserver, never()).onNext(anyString());
         verify(aObserver, times(1)).onCompleted();
@@ -210,38 +219,31 @@ public void testAggregatorSimple() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorDifferentSizedResultsWithOnComplete() {
-        FuncN zipr = getConcatZipr();
         /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        /* define a Observer to receive aggregated events */
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, "world");
-        a.complete(r2);
+        r1.onNext("hello");
+        r2.onNext("world");
+        r2.onCompleted();
 
         InOrder inOrder = inOrder(aObserver);
 
         inOrder.verify(aObserver, never()).onError(any(Throwable.class));
-        inOrder.verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, times(1)).onNext("helloworld");
+        inOrder.verify(aObserver, times(1)).onCompleted();
 
-        a.next(r1, "hi");
-        a.complete(r1);
+        r1.onNext("hi");
+        r1.onCompleted();
 
         inOrder.verify(aObserver, never()).onError(any(Throwable.class));
-        inOrder.verify(aObserver, times(1)).onCompleted();
+        inOrder.verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, never()).onNext(anyString());
     }
 
@@ -249,38 +251,29 @@ public void testAggregatorDifferentSizedResultsWithOnComplete() {
     /* mock calls don't do generics */
     @Test
     public void testAggregateMultipleTypes() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);        
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, "world");
-        a.complete(r2);
+        r1.onNext("hello");
+        r2.onNext(1);
+        r2.onCompleted();
 
         InOrder inOrder = inOrder(aObserver);
 
         inOrder.verify(aObserver, never()).onError(any(Throwable.class));
-        inOrder.verify(aObserver, never()).onCompleted();
-        inOrder.verify(aObserver, times(1)).onNext("helloworld");
+        inOrder.verify(aObserver, times(1)).onNext("hello1");
+        inOrder.verify(aObserver, times(1)).onCompleted();
 
-        a.next(r1, "hi");
-        a.complete(r1);
+        r1.onNext("hi");
+        r1.onCompleted();
 
         inOrder.verify(aObserver, never()).onError(any(Throwable.class));
-        inOrder.verify(aObserver, times(1)).onCompleted();
+        inOrder.verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, never()).onNext(anyString());
     }
 
@@ -288,28 +281,18 @@ public void testAggregateMultipleTypes() {
     /* mock calls don't do generics */
     @Test
     public void testAggregate3Types() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
+        PublishSubject> r3 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-        ZipObserver r3 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
-        a.addObserver(r3);
+        
+        Observable.zip(r1, r2, r3, zipr3).subscribe(aObserver);        
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, 2);
-        a.next(r3, new int[] { 5, 6, 7 });
+        r1.onNext("hello");
+        r2.onNext(2);
+        r3.onNext(Arrays.asList( 5, 6, 7 ));
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
@@ -320,43 +303,34 @@ public void testAggregate3Types() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorsWithDifferentSizesAndTiming() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "one");
-        a.next(r1, "two");
-        a.next(r1, "three");
-        a.next(r2, "A");
+        r1.onNext("one");
+        r1.onNext("two");
+        r1.onNext("three");
+        r2.onNext("A");
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
         verify(aObserver, times(1)).onNext("oneA");
 
-        a.next(r1, "four");
-        a.complete(r1);
-        a.next(r2, "B");
+        r1.onNext("four");
+        r1.onCompleted();
+        r2.onNext("B");
         verify(aObserver, times(1)).onNext("twoB");
-        a.next(r2, "C");
+        r2.onNext("C");
         verify(aObserver, times(1)).onNext("threeC");
-        a.next(r2, "D");
+        r2.onNext("D");
         verify(aObserver, times(1)).onNext("fourD");
-        a.next(r2, "E");
+        r2.onNext("E");
         verify(aObserver, never()).onNext("E");
-        a.complete(r2);
+        r2.onCompleted();
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, times(1)).onCompleted();
@@ -366,33 +340,24 @@ public void testAggregatorsWithDifferentSizesAndTiming() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorError() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, "world");
+        r1.onNext("hello");
+        r2.onNext("world");
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
         verify(aObserver, times(1)).onNext("helloworld");
 
-        a.error(r1, new RuntimeException(""));
-        a.next(r1, "hello");
-        a.next(r2, "again");
+        r1.onError(new RuntimeException(""));
+        r1.onNext("hello");
+        r2.onNext("again");
 
         verify(aObserver, times(1)).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
@@ -404,33 +369,24 @@ public void testAggregatorError() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorUnsubscribe() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        Subscription subscription = a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Subscription subscription = Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "hello");
-        a.next(r2, "world");
+        r1.onNext("hello");
+        r2.onNext("world");
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
         verify(aObserver, times(1)).onNext("helloworld");
 
         subscription.unsubscribe();
-        a.next(r1, "hello");
-        a.next(r2, "again");
+        r1.onNext("hello");
+        r2.onNext("again");
 
         verify(aObserver, times(0)).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
@@ -442,27 +398,18 @@ public void testAggregatorUnsubscribe() {
     /* mock calls don't do generics */
     @Test
     public void testAggregatorEarlyCompletion() {
-        FuncN zipr = getConcatZipr();
-        /* create the aggregator which will execute the zip function when all Observables provide values */
-        Aggregator a = new Aggregator(zipr);
-
+        PublishSubject r1 = PublishSubject.create();
+        PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        a.onSubscribe(aObserver);
-
-        /* mock the Observable Observers that are 'pushing' data for us */
-        ZipObserver r1 = mock(ZipObserver.class);
-        ZipObserver r2 = mock(ZipObserver.class);
-
-        /* pretend we're starting up */
-        a.addObserver(r1);
-        a.addObserver(r2);
+        
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
-        a.next(r1, "one");
-        a.next(r1, "two");
-        a.complete(r1);
-        a.next(r2, "A");
+        r1.onNext("one");
+        r1.onNext("two");
+        r1.onCompleted();
+        r2.onNext("A");
 
         InOrder inOrder = inOrder(aObserver);
 
@@ -470,7 +417,7 @@ public void testAggregatorEarlyCompletion() {
         inOrder.verify(aObserver, never()).onCompleted();
         inOrder.verify(aObserver, times(1)).onNext("oneA");
 
-        a.complete(r2);
+        r2.onCompleted();
 
         inOrder.verify(aObserver, never()).onError(any(Throwable.class));
         inOrder.verify(aObserver, times(1)).onCompleted();
@@ -533,21 +480,21 @@ public void testOnFirstCompletion() {
         PublishSubject oB = PublishSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer observer = mock(Observer.class);
+        Observer obs = mock(Observer.class);
 
         Observable o = Observable.create(zip(oA, oB, getConcat2Strings()));
-        o.subscribe(observer);
+        o.subscribe(obs);
 
-        InOrder inOrder = inOrder(observer);
+        InOrder io = inOrder(obs);
 
         oA.onNext("a1");
-        inOrder.verify(observer, never()).onNext(anyString());
+        io.verify(obs, never()).onNext(anyString());
         oB.onNext("b1");
-        inOrder.verify(observer, times(1)).onNext("a1-b1");
+        io.verify(obs, times(1)).onNext("a1-b1");
         oB.onNext("b2");
-        inOrder.verify(observer, never()).onNext(anyString());
+        io.verify(obs, never()).onNext(anyString());
         oA.onNext("a2");
-        inOrder.verify(observer, times(1)).onNext("a2-b2");
+        io.verify(obs, times(1)).onNext("a2-b2");
 
         oA.onNext("a3");
         oA.onNext("a4");
@@ -561,12 +508,12 @@ public void testOnFirstCompletion() {
         oB.onNext("b4");
         oB.onNext("b5");
 
-        inOrder.verify(observer, times(1)).onNext("a3-b3");
-        inOrder.verify(observer, times(1)).onNext("a4-b4");
-        inOrder.verify(observer, times(1)).onNext("a5-b5");
+        io.verify(obs, times(1)).onNext("a3-b3");
+        io.verify(obs, times(1)).onNext("a4-b4");
+        io.verify(obs, times(1)).onNext("a5-b5");
 
         // WE RECEIVE THE ONCOMPLETE HERE
-        inOrder.verify(observer, times(1)).onCompleted();
+        io.verify(obs, times(1)).onCompleted();
 
         oB.onNext("b6");
         oB.onNext("b7");
@@ -575,7 +522,7 @@ public void testOnFirstCompletion() {
         // never completes (infinite stream for example)
 
         // we should receive nothing else despite oB continuing after oA completed
-        inOrder.verifyNoMoreInteractions();
+        io.verifyNoMoreInteractions();
     }
     
     @Test
@@ -584,21 +531,21 @@ public void testOnErrorTermination() {
         PublishSubject oB = PublishSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer observer = mock(Observer.class);
+        Observer obs = mock(Observer.class);
 
         Observable o = Observable.create(zip(oA, oB, getConcat2Strings()));
-        o.subscribe(observer);
+        o.subscribe(obs);
 
-        InOrder inOrder = inOrder(observer);
+        InOrder io = inOrder(obs);
 
         oA.onNext("a1");
-        inOrder.verify(observer, never()).onNext(anyString());
+        io.verify(obs, never()).onNext(anyString());
         oB.onNext("b1");
-        inOrder.verify(observer, times(1)).onNext("a1-b1");
+        io.verify(obs, times(1)).onNext("a1-b1");
         oB.onNext("b2");
-        inOrder.verify(observer, never()).onNext(anyString());
+        io.verify(obs, never()).onNext(anyString());
         oA.onNext("a2");
-        inOrder.verify(observer, times(1)).onNext("a2-b2");
+        io.verify(obs, times(1)).onNext("a2-b2");
 
         oA.onNext("a3");
         oA.onNext("a4");
@@ -606,7 +553,7 @@ public void testOnErrorTermination() {
         oA.onError(new RuntimeException("forced failure"));
 
         // it should emit failure immediately
-        inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
+        io.verify(obs, times(1)).onError(any(RuntimeException.class));
 
         oB.onNext("b3");
         oB.onNext("b4");
@@ -618,7 +565,7 @@ public void testOnErrorTermination() {
         // never completes (infinite stream for example)
 
         // we should receive nothing else despite oB continuing after oA completed
-        inOrder.verifyNoMoreInteractions();
+        io.verifyNoMoreInteractions();
     }
 
     private Func2 getConcat2Strings() {
@@ -815,4 +762,255 @@ public void testSecondFails() {
 		inOrder.verify(observer, never()).onNext(any(String.class));
 		inOrder.verifyNoMoreInteractions();
 	}
+    
+    @Test
+    public void testZipIterableSameSize() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+        
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onNext("three-3");
+        io.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    @Test
+    public void testZipIterableEmptyFirstSize() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+        
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onCompleted();
+        
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    @Test
+    public void testZipIterableEmptySecond() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList();
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+        
+        io.verify(o).onCompleted();
+        
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testZipIterableFirstShorter() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onCompleted();
+        
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    
+    @Test
+    public void testZipIterableSecondShorter() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2");
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+        
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    @Test
+    public void testZipIterableFirstThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onError(new OperationReduceTest.CustomException());
+        
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onCompleted();
+        
+    }
+    
+    @Test
+    public void testZipIterableIteratorThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+            @Override
+            public Iterator iterator() {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onError(new OperationReduceTest.CustomException());
+        
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any(String.class));
+        
+    }
+    @Test
+    public void testZipIterableHasNextThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+
+            @Override
+            public Iterator iterator() {
+                return new Iterator() {
+                    int count;
+                    @Override
+                    public boolean hasNext() {
+                        if (count == 0) {
+                            return true;
+                        }
+                        throw new CustomException();
+                    }
+
+                    @Override
+                    public String next() {
+                        count++;
+                        return "1";
+                    }
+
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+                    
+                };
+            }
+            
+        };
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onNext("one-");
+        r1.onError(new OperationReduceTest.CustomException());
+        
+        io.verify(o).onNext("one-1");
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onCompleted();
+        
+    }
+    @Test
+    public void testZipIterableNextThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+
+            @Override
+            public Iterator iterator() {
+                return new Iterator() {
+                    int count;
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+
+                    @Override
+                    public String next() {
+                        throw new CustomException();
+                    }
+
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+                    
+                };
+            }
+            
+        };
+        
+        r1.zip(r2, zipr2).subscribe(o);
+        
+        r1.onError(new OperationReduceTest.CustomException());
+        
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onCompleted();
+        
+    }
 }

From ccc2784ce43081ac94ce9ee81fd88a565359020e Mon Sep 17 00:00:00 2001
From: Luke Daley 
Date: Sat, 11 Jan 2014 13:53:05 +0000
Subject: [PATCH 203/441] Build with Gradle 1.10.

Required that the IDE plugins also be applied to the root, because of the improved Scala support with the IDEA plugin.
---
 build.gradle                             | 5 ++---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/build.gradle b/build.gradle
index c144c169e6..344501b305 100644
--- a/build.gradle
+++ b/build.gradle
@@ -15,6 +15,8 @@ buildscript {
 }
 
 allprojects {
+    apply plugin: 'eclipse'
+    apply plugin: 'idea'
     repositories { 
         mavenLocal()
         mavenCentral() // maven { url: 'http://jcenter.bintray.com' }
@@ -23,9 +25,6 @@ allprojects {
 
 subprojects {
     apply plugin: 'java'
-    apply plugin: 'eclipse'
-    apply plugin: 'idea'
-
     group = "com.netflix.rxjava"
 
     // make 'examples' use the same classpath
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 6d35fb3bc3..2c79588016 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.6-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip

From 337efeb42f1ec27679632718fd022d98f61efa1a Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Mon, 13 Jan 2014 09:06:43 +0100
Subject: [PATCH 204/441] Modified to conform Rx.NET

---
 rxjava-core/src/main/java/rx/Observable.java  |  13 +--
 .../java/rx/operators/OperationDelay.java     |  87 +++++++++------
 .../java/rx/operators/OperationDelayTest.java | 104 +++++++++++-------
 3 files changed, 117 insertions(+), 87 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 87bce6ba27..ba777759cb 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2170,10 +2170,7 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
     /**
      * Create an Observable which delays the events via another Observable on a per item-basis.
      * 
    
-     * Note: onError or onCompleted events are immediately propagated.
-     * 
    
-     * Note: if the Observable returned by the {@code itemDelay} just completes, that
-     * particular source item is not emitted.
+     * Note: onError event is immediately propagated.
      * 
      * @param  the item delay value type (ignored)
      * @param itemDelay function that returns an Observable for each source item which is
@@ -2187,13 +2184,7 @@ public  Observable delay(Func1> itemDel
     /**
      * Create an Observable which delays the subscription and events via another Observables on a per item-basis.
      * 
    
-     * Note: onError or onCompleted events are immediately propagated.
-     * 
    
-     * Note: if the Observable returned by the {@code itemDelay} just completes, that
-     * particular source item is not emitted.
-     * 
    
-     * Note: if the {@code subscriptionDelay}'s Observable just completes, the created
-     * observable will just complete as well.
+     * Note: onError event is immediately propagated.
      * 
      * @param  the subscription delay value type (ignored)
      * @param  the item delay value type (ignored)
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 56d9de1cb3..e553d09b60 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -120,8 +120,11 @@ public DelayViaObservable(Observable source,
         public Subscription onSubscribe(Observer t1) {
             CompositeSubscription csub = new CompositeSubscription();
             
+            SerialSubscription sosub = new SerialSubscription();
+            csub.add(sosub);
+            SourceObserver so = new SourceObserver(t1, itemDelay, csub, sosub);
             if (subscriptionDelay == null) {
-                csub.add(source.subscribe(new SourceObserver(t1, itemDelay, csub)));
+                sosub.set(source.subscribe(so));
             } else {
                 Observable subscriptionSource;
                 try {
@@ -132,50 +135,48 @@ public Subscription onSubscribe(Observer t1) {
                 }
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
-                ssub.set(subscriptionSource.subscribe(new SubscribeDelay(source, t1, itemDelay, csub, ssub)));
+                ssub.set(subscriptionSource.subscribe(new SubscribeDelay(source, so, csub, ssub)));
             }
             
             return csub;
         }
+        /** Subscribe delay observer. */
         private static final class SubscribeDelay implements Observer {
             final Observable source;
-            final Observer observer;
-            final Func1> itemDelay;
+            final SourceObserver so;
             final CompositeSubscription csub;
             final Subscription self;
-            /** Prevent any onError and onCompleted once the first item was delivered. */
+            /** Prevent any onError once the first item was delivered. */
             boolean subscribed;
 
-            public SubscribeDelay(Observable source, Observer observer, Func1> itemDelay, 
+            public SubscribeDelay(
+                    Observable source,
+                    SourceObserver so, 
                     CompositeSubscription csub, Subscription self) {
                 this.source = source;
-                this.observer = observer;
-                this.itemDelay = itemDelay;
+                this.so = so;
                 this.csub = csub;
                 this.self = self;
             }
 
             @Override
             public void onNext(U args) {
-                subscribed = true;
-                csub.remove(self);
-                csub.add(source.subscribe(new SourceObserver(observer, itemDelay, csub)));
+                onCompleted();
             }
 
             @Override
             public void onError(Throwable e) {
                 if (!subscribed) {
-                    observer.onError(e);
+                    so.observer.onError(e);
                     csub.unsubscribe();
                 }
             }
 
             @Override
             public void onCompleted() {
-                if (!subscribed) {
-                    observer.onCompleted();
-                    csub.unsubscribe();
-                }
+                subscribed = true;
+                csub.remove(self);
+                so.self.set(source.subscribe(so));
             }
         }
         /** The source observer. */
@@ -183,15 +184,21 @@ private static final class SourceObserver implements Observer {
             final Observer observer;
             final Func1> itemDelay;
             final CompositeSubscription csub;
+            final SerialSubscription self;
             /** Guard to avoid overlapping events from the various sources. */
             final Object guard;
             boolean done;
+            int wip;
 
-            public SourceObserver(Observer observer, Func1> itemDelay, CompositeSubscription csub) {
+            public SourceObserver(Observer observer, 
+                    Func1> itemDelay, 
+                    CompositeSubscription csub,
+                    SerialSubscription self) {
                 this.observer = observer;
                 this.itemDelay = itemDelay;
                 this.csub = csub;
                 this.guard = new Object();
+                this.self = self;
             }
 
             @Override
@@ -203,19 +210,19 @@ public void onNext(T args) {
                     onError(t);
                     return;
                 }
+                
+                synchronized (guard) {
+                    wip++;
+                }
+                
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
-                
                 ssub.set(delayer.subscribe(new DelayObserver(args, this, ssub)));
             }
 
             @Override
             public void onError(Throwable e) {
                 synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
-                    done = true;
                     observer.onError(e);
                 }
                 csub.unsubscribe();
@@ -223,27 +230,37 @@ public void onError(Throwable e) {
 
             @Override
             public void onCompleted() {
+                boolean b;
                 synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
                     done = true;
-                    observer.onCompleted();
+                    b = checkDone();
+                }
+                if (b) {
+                    csub.unsubscribe();
+                } else {
+                    self.unsubscribe();
                 }
-                csub.unsubscribe();
             }
             
-            public void emit(T value, Subscription token) {
+            void emit(T value, Subscription token) {
+                boolean b;
                 synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
                     observer.onNext(value);
+                    wip--;
+                    b = checkDone();
+                }
+                if (b) {
+                    csub.unsubscribe();
+                } else {
+                    csub.remove(token);
                 }
-                remove(token);
             }
-            public void remove(Subscription token) {
-                csub.remove(token);
+            boolean checkDone() {
+                if (done && wip == 0) {
+                    observer.onCompleted();
+                    return true;
+                }
+                return false;
             }
         }
         /**
@@ -272,7 +289,7 @@ public void onError(Throwable e) {
 
             @Override
             public void onCompleted() {
-                parent.remove(token);
+                parent.emit(value, token);
             }
             
         }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
index f040a012c2..81728753c6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
@@ -276,47 +276,7 @@ public Observable call(Integer t1) {
         
         verify(o, never()).onError(any(Throwable.class));
     }
-    @Test
-    public void testDelayWithObservableSkipper1() {
-        PublishSubject source = PublishSubject.create();
-        final List> delays = new ArrayList>();
-        final int n = 10;
-        for (int i = 0; i < n; i++) {
-            PublishSubject delay = PublishSubject.create();
-            delays.add(delay);
-        }
-
-        Func1> delayFunc = new Func1>() {
-            @Override
-            public Observable call(Integer t1) {
-                return delays.get(t1);
-            }
-        };
-        
-        @SuppressWarnings("unchecked")
-        Observer o = mock(Observer.class);
-        InOrder inOrder = inOrder(o);
-        
-        source.delay(delayFunc).subscribe(o);
-        
-        
-        for (int i = 0; i < n; i++) {
-            source.onNext(i);
-            if (i % 2 == 0) {
-                delays.get(i).onNext(i);
-                inOrder.verify(o).onNext(i);
-            } else {
-                delays.get(i).onCompleted();
-                inOrder.verify(o, never()).onNext(i);
-            }
-        }
-        source.onCompleted();
-        
-        inOrder.verify(o).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-        
-        verify(o, never()).onError(any(Throwable.class));
-    }
+    
     @Test
     public void testDelayWithObservableSingleSend1() {
         PublishSubject source = PublishSubject.create();
@@ -521,4 +481,66 @@ public Observable call(Integer t1) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+    @Test
+    public void testDelayWithObservableEmptyDelayer() {
+        PublishSubject source = PublishSubject.create();
+
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return Observable.empty();
+            }
+        };
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        source.onCompleted();
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testDelayWithObservableSubscriptionRunCompletion() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject sdelay = PublishSubject.create();
+        final PublishSubject delay = PublishSubject.create();
+        Func0> subFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return sdelay;
+            }
+        };
+        Func1> delayFunc = new Func1>() {
+
+            @Override
+            public Observable call(Integer t1) {
+                return delay;
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.delay(subFunc, delayFunc).subscribe(o);
+        
+        source.onNext(1);
+        sdelay.onCompleted();
+
+        source.onNext(2);
+        delay.onNext(2);
+        
+        inOrder.verify(o).onNext(2);
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+        verify(o, never()).onCompleted();
+    }
 }

From a041883e56b670f2784372745feed4926b605413 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Mon, 13 Jan 2014 17:28:31 +0800
Subject: [PATCH 205/441] Fixed issue #737

---
 .../java/rx/operators/OperationSwitch.java    |  9 ++--
 .../rx/operators/OperationSwitchTest.java     | 47 +++++++++++++++++++
 2 files changed, 51 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 9094a2affd..9b81a32cf1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -126,13 +126,12 @@ public void onCompleted() {
                         sub.unsubscribe();
                         if (latest == id) {
                             SwitchObserver.this.hasLatest = false;
-                        }
 
-                        if (stopped) {
-                            SwitchObserver.this.observer.onCompleted();
-                            SwitchObserver.this.parent.unsubscribe();
+                            if (stopped) {
+                                SwitchObserver.this.observer.onCompleted();
+                                SwitchObserver.this.parent.unsubscribe();
+                            }
                         }
-
                     }
                 }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index 8afa5557f1..76490f1cec 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -380,4 +380,51 @@ public void call() {
     @SuppressWarnings("serial")
     private class TestException extends Throwable {
     }
+
+    @Test
+    public void testSwitchIssue737() {
+        // https://github.com/Netflix/RxJava/issues/737
+        Observable> source = Observable.create(new Observable.OnSubscribeFunc>() {
+            @Override
+            public Subscription onSubscribe(Observer> observer) {
+                publishNext(observer, 0, Observable.create(new Observable.OnSubscribeFunc() {
+                    @Override
+                    public Subscription onSubscribe(Observer observer) {
+                        publishNext(observer, 10, "1-one");
+                        publishNext(observer, 20, "1-two");
+                        // The following events will be ignored
+                        publishNext(observer, 30, "1-three");
+                        publishCompleted(observer, 40);
+                        return Subscriptions.empty();
+                    }
+                }));
+                publishNext(observer, 25, Observable.create(new Observable.OnSubscribeFunc() {
+                    @Override
+                    public Subscription onSubscribe(Observer observer) {
+                        publishNext(observer, 10, "2-one");
+                        publishNext(observer, 20, "2-two");
+                        publishNext(observer, 30, "2-three");
+                        publishCompleted(observer, 40);
+                        return Subscriptions.empty();
+                    }
+                }));
+                publishCompleted(observer, 30);
+                return Subscriptions.empty();
+            }
+        });
+
+        Observable sampled = Observable.create(OperationSwitch.switchDo(source));
+        sampled.subscribe(observer);
+
+        scheduler.advanceTimeTo(1000, TimeUnit.MILLISECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext("1-one");
+        inOrder.verify(observer, times(1)).onNext("1-two");
+        inOrder.verify(observer, times(1)).onNext("2-one");
+        inOrder.verify(observer, times(1)).onNext("2-two");
+        inOrder.verify(observer, times(1)).onNext("2-three");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
 }

From 8e5e3e13850d490fd3114e8703821e21f1c9d1dd Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Mon, 13 Jan 2014 18:05:06 +0800
Subject: [PATCH 206/441] Replaced MultipleAssignmentSubscription with
 SerialSubscription

---
 .../src/main/java/rx/operators/OperationSwitch.java      | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 9b81a32cf1..0005dcd66f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -20,7 +20,7 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.MultipleAssignmentSubscription;
+import rx.subscriptions.SerialSubscription;
 import rx.util.functions.Func1;
 
 /**
@@ -62,8 +62,7 @@ public Subscription onSubscribe(Observer observer) {
             SafeObservableSubscription parent;
             parent = new SafeObservableSubscription();
 
-            MultipleAssignmentSubscription child;
-            child = new MultipleAssignmentSubscription();
+            SerialSubscription child = new SerialSubscription();
 
             parent.wrap(sequences.subscribe(new SwitchObserver(observer, parent, child)));
 
@@ -76,13 +75,13 @@ private static class SwitchObserver implements Observer observer;
         private final SafeObservableSubscription parent;
-        private final MultipleAssignmentSubscription child;
+        private final SerialSubscription child;
         private long latest;
         private boolean stopped;
         private boolean hasLatest;
 
         public SwitchObserver(Observer observer, SafeObservableSubscription parent,
-                MultipleAssignmentSubscription child) {
+                SerialSubscription child) {
             this.observer = observer;
             this.parent = parent;
             this.child = child;

From 5fe7d1d1ebfb9e617736be68fe84c082d125bdca Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Mon, 13 Jan 2014 18:34:21 +0800
Subject: [PATCH 207/441] Moved unsubscribe out the gate

---
 .../java/rx/operators/OperationSwitch.java    | 25 +++++++++++++------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 0005dcd66f..634801f19b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -96,8 +96,7 @@ public void onNext(Observable args) {
                 this.hasLatest = true;
             }
 
-            final SafeObservableSubscription sub;
-            sub = new SafeObservableSubscription();
+            final SafeObservableSubscription sub = new SafeObservableSubscription();
             sub.wrap(args.subscribe(new Observer() {
                 @Override
                 public void onNext(T args) {
@@ -110,28 +109,36 @@ public void onNext(T args) {
 
                 @Override
                 public void onError(Throwable e) {
+                    sub.unsubscribe();
+                    SafeObservableSubscription s = null;
                     synchronized (gate) {
-                        sub.unsubscribe();
                         if (latest == id) {
                             SwitchObserver.this.observer.onError(e);
-                            SwitchObserver.this.parent.unsubscribe();
+                            s = SwitchObserver.this.parent;
                         }
                     }
+                    if(s != null) {
+                        s.unsubscribe();
+                    }
                 }
 
                 @Override
                 public void onCompleted() {
+                    sub.unsubscribe();
+                    SafeObservableSubscription s = null;
                     synchronized (gate) {
-                        sub.unsubscribe();
                         if (latest == id) {
                             SwitchObserver.this.hasLatest = false;
 
                             if (stopped) {
                                 SwitchObserver.this.observer.onCompleted();
-                                SwitchObserver.this.parent.unsubscribe();
+                                s = SwitchObserver.this.parent;
                             }
                         }
                     }
+                    if(s != null) {
+                        s.unsubscribe();
+                    }
                 }
 
             }));
@@ -150,13 +157,17 @@ public void onError(Throwable e) {
 
         @Override
         public void onCompleted() {
+            SafeObservableSubscription s = null;
             synchronized (gate) {
                 this.stopped = true;
                 if (!this.hasLatest) {
                     this.observer.onCompleted();
-                    this.parent.unsubscribe();
+                    s = this.parent;
                 }
             }
+            if(s != null) {
+                s.unsubscribe();
+            }
         }
 
     }

From 83aa8574a441c1d621b1b3299584d8290c692937 Mon Sep 17 00:00:00 2001
From: Christopher Grimm 
Date: Mon, 13 Jan 2014 14:35:38 -0500
Subject: [PATCH 208/441] modified groupByUntil include the key of the group in
 the closings function.

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala | 13 ++++++++++++-
 .../src/main/scala/rx/lang/scala/Observable.scala  | 14 ++++++--------
 rxjava-core/src/main/java/rx/Observable.java       |  4 ++--
 .../java/rx/operators/OperationGroupByUntil.java   |  8 ++++----
 4 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
index 048df5dc74..bf1d12b425 100644
--- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
+++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
@@ -242,6 +242,17 @@ class RxScalaDemo extends JUnitSuite {
     waitFor(firstMedalOfEachCountry)
   }
 
+  @Test def groupByUntilExample() {
+    val numbers = Observable.interval(250 millis) take 14
+    val grouped = numbers.groupByUntil[Long, Long](
+      {case x => x % 2},
+      {case (key, obs) => obs filter {case x => x == 7}}
+    )
+    val sequenced = (grouped map {case (key, obs) => obs.toSeq}).flatten
+    sequenced subscribe {x => println(s"Emitted group: $x")}
+  }
+
+
   @Test def olympicsExample() {
     val medals = Olympics.mountainBikeMedals.publish
     medals.subscribe(println(_))
@@ -449,4 +460,4 @@ class RxScalaDemo extends JUnitSuite {
     obs.toBlockingObservable.toIterable.last
   }
 
-}
\ No newline at end of file
+}
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index ca84a23b2f..f97c865a1d 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -1332,20 +1332,18 @@ trait Observable[+T]
    * @param f
    *            a function that extracts the key from an item
    * @param closings
-   *            the function that accepts a created grouping and emits an observable which upon emitting a Closing, 
-   *            closes the group.
+   *            the function that accepts the key of a given group and an observable representing that group, and returns
+   *            an observable that emits a single Closing when the group should be closed.
    * @tparam K 
    *            the type of the keys returned by the discriminator function.
    * @tparam Closing
    *            the type of the element emitted from the closings observable.
-   * @return an Observable that emits `(key, observable)`pairs, where `observable`
+   * @return an Observable that emits `(key, observable)` pairs, where `observable`
    *         contains all items for which `f` returned `key` before `closings` emits a value.
    */
-  def groupByUntil[K, Closing](f: T => K, closings: Observable[T]=>Observable[Closing]): Observable[(K, Observable[T])] = {
-    val closing = (o: rx.observables.GroupedObservable[K,T]) => closings(toScalaObservable[T](o)).asJavaObservable
-    val fclosing = new Func1[rx.observables.GroupedObservable[K, T], rx.Observable[_ <: Closing]] {
-      def call(o: rx.observables.GroupedObservable[K, T]) = closing(o)
-    }.asInstanceOf[Func1[_ >: rx.observables.GroupedObservable[K, _ <: T], _ <: rx.Observable[Closing]]]
+  def groupByUntil[K, Closing](f: T => K, closings: (K, Observable[T])=>Observable[Closing]): Observable[(K, Observable[T])] = {
+    val fclosing: Func1[_ >: rx.observables.GroupedObservable[K, _ <: T], _ <: rx.Observable[_ <: Closing]] =
+      (jGrObs: rx.observables.GroupedObservable[K, _ <: T]) => closings(jGrObs.getKey, toScalaObservable[T](jGrObs)).asJavaObservable
     val o1 = asJavaObservable.groupByUntil[K, Closing](f, fclosing) : rx.Observable[_ <: rx.observables.GroupedObservable[K, _ <: T]]
     val func = (o: rx.observables.GroupedObservable[K, _ <: T]) => (o.getKey, toScalaObservable[T](o))
     toScalaObservable[(K, Observable[T])](o1.map[(K, Observable[T])](func))
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 92fb348879..af6cbcda18 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7552,7 +7552,7 @@ public  Observable skipUntil(Observable other) {
      * @see RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
+    public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
         return groupByUntil(keySelector, Functions.identity(), durationSelector);
     }
     
@@ -7573,7 +7573,7 @@ public  Observable> groupByUntil(Fun
      * @see RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
+    public  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
         return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector));
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index 63a271a688..d4f1406c9b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -42,11 +42,11 @@ public class OperationGroupByUntil implements
     final Observable source;
     final Func1 keySelector;
     final Func1 valueSelector;
-    final Func1, ? extends Observable> durationSelector;
+    final Func1, ? extends Observable> durationSelector;
     public OperationGroupByUntil(Observable source,
             Func1 keySelector,
             Func1 valueSelector,
-            Func1, ? extends Observable> durationSelector) {
+            Func1, ? extends Observable> durationSelector) {
         this.source = source;
         this.keySelector = keySelector;
         this.valueSelector = valueSelector;
@@ -107,7 +107,7 @@ public void onNext(TSource args) {
             }
             
             if (newGroup) {
-                Observable duration;
+                Observable duration;
                 try {
                     duration = durationSelector.call(g);
                 } catch (Throwable t) {
@@ -234,4 +234,4 @@ public void onCompleted() {
         }
         
     }
-}
\ No newline at end of file
+}

From 22233acb8e3d92ceede872252bb48036c5ec45c8 Mon Sep 17 00:00:00 2001
From: Jeffrey Yu 
Date: Mon, 13 Jan 2014 22:40:27 -0800
Subject: [PATCH 209/441] Separated Android test code from source.

---
 .../observables/AndroidObservable.java        |  58 -----
 .../schedulers/HandlerThreadScheduler.java    |  53 -----
 .../OperationObserveFromAndroidComponent.java | 164 --------------
 .../observables/AndroidObservableTest.java    |  85 +++++++
 ...rationObserveFromAndroidComponentTest.java | 213 ++++++++++++++++++
 .../HandlerThreadSchedulerTest.java           |  81 +++++++
 6 files changed, 379 insertions(+), 275 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java
 create mode 100644 rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
 create mode 100644 rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
index 5ae8a11a74..be471b6291 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
@@ -15,16 +15,6 @@
  */
 package rx.android.observables;
 
-import static org.mockito.Mockito.verify;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.Robolectric;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.annotation.Config;
 import rx.Observable;
 import rx.Observer;
 import rx.operators.OperationObserveFromAndroidComponent;
@@ -108,52 +98,4 @@ public static  Observable fromFragment(Object fragment, Observable sour
             throw new IllegalArgumentException("Target fragment is neither a native nor support library Fragment");
         }
     }
-
-    @RunWith(RobolectricTestRunner.class)
-    @Config(manifest = Config.NONE)
-    public static final class AndroidObservableTest {
-
-        // support library fragments
-        private FragmentActivity fragmentActivity;
-        private android.support.v4.app.Fragment supportFragment;
-
-        // native fragments
-        private Activity activity;
-        private Fragment fragment;
-
-        @Mock
-        private Observer observer;
-
-        @Before
-        public void setup() {
-            MockitoAnnotations.initMocks(this);
-            supportFragment = new android.support.v4.app.Fragment();
-            fragmentActivity = Robolectric.buildActivity(FragmentActivity.class).create().get();
-            fragmentActivity.getSupportFragmentManager().beginTransaction().add(supportFragment, null).commit();
-
-            fragment = new Fragment();
-            activity = Robolectric.buildActivity(Activity.class).create().get();
-            activity.getFragmentManager().beginTransaction().add(fragment, null).commit();
-        }
-
-        @Test
-        public void itSupportsFragmentsFromTheSupportV4Library() {
-            fromFragment(supportFragment, Observable.just("success")).subscribe(observer);
-            verify(observer).onNext("success");
-            verify(observer).onCompleted();
-        }
-
-        @Test
-        public void itSupportsNativeFragments() {
-            fromFragment(fragment, Observable.just("success")).subscribe(observer);
-            verify(observer).onNext("success");
-            verify(observer).onCompleted();
-        }
-
-        @Test(expected = IllegalArgumentException.class)
-        public void itThrowsIfObjectPassedIsNotAFragment() {
-            fromFragment("not a fragment", Observable.never());
-        }
-    }
-
 }
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
index 8535dda295..5ce5856d86 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
@@ -17,12 +17,6 @@
 
 import android.os.Handler;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.annotation.Config;
-
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
@@ -30,10 +24,6 @@
 
 import java.util.concurrent.TimeUnit;
 
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
 /**
  * Schedules actions to run on an Android Handler thread.
  */
@@ -84,49 +74,6 @@ public void run() {
         }, unit.toMillis(delayTime));
         return subscription;
     }
-
-    @RunWith(RobolectricTestRunner.class)
-    @Config(manifest=Config.NONE)
-    public static final class UnitTest {
-
-        @Test
-        public void shouldScheduleImmediateActionOnHandlerThread() {
-            final Handler handler = mock(Handler.class);
-            final Object state = new Object();
-            @SuppressWarnings("unchecked")
-            final Func2 action = mock(Func2.class);
-
-            Scheduler scheduler = new HandlerThreadScheduler(handler);
-            scheduler.schedule(state, action);
-
-            // verify that we post to the given Handler
-            ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class);
-            verify(handler).postDelayed(runnable.capture(), eq(0L));
-
-            // verify that the given handler delegates to our action
-            runnable.getValue().run();
-            verify(action).call(scheduler, state);
-        }
-
-        @Test
-        public void shouldScheduleDelayedActionOnHandlerThread() {
-            final Handler handler = mock(Handler.class);
-            final Object state = new Object();
-            @SuppressWarnings("unchecked")
-            final Func2 action = mock(Func2.class);
-
-            Scheduler scheduler = new HandlerThreadScheduler(handler);
-            scheduler.schedule(state, action, 1L, TimeUnit.SECONDS);
-
-            // verify that we post to the given Handler
-            ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class);
-            verify(handler).postDelayed(runnable.capture(), eq(1000L));
-
-            // verify that the given handler delegates to our action
-            runnable.getValue().run();
-            verify(action).call(scheduler, state);
-        }
-    }
 }
 
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
index 06b22dae5c..4ebf6b117a 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
@@ -15,23 +15,6 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.annotation.Config;
-
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
@@ -42,7 +25,6 @@
 import android.os.Looper;
 import android.util.Log;
 
-import java.lang.reflect.Field;
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -164,150 +146,4 @@ protected boolean isComponentValid(android.support.v4.app.Fragment fragment) {
             return fragment.isAdded();
         }
     }
-
-    @RunWith(RobolectricTestRunner.class)
-    @Config(manifest = Config.NONE)
-    public static final class UnitTest {
-
-        @Mock
-        private Observer mockObserver;
-
-        @Mock
-        private Fragment mockFragment;
-
-        @Mock
-        private Activity mockActivity;
-
-        @Mock
-        private Observable mockObservable;
-
-        @Before
-        public void setupMocks() {
-            MockitoAnnotations.initMocks(this);
-            when(mockFragment.isAdded()).thenReturn(true);
-        }
-
-        @Test
-        public void itThrowsIfObserverSubscribesFromBackgroundThread() throws Exception {
-            final Future future = Executors.newSingleThreadExecutor().submit(new Callable() {
-                @Override
-                public Object call() throws Exception {
-                    OperationObserveFromAndroidComponent.observeFromAndroidComponent(
-                            mockObservable, mockFragment).subscribe(mockObserver);
-                    return null;
-                }
-            });
-            future.get(1, TimeUnit.SECONDS);
-            verify(mockObserver).onError(any(IllegalStateException.class));
-            verifyNoMoreInteractions(mockObserver);
-        }
-
-        @Test
-        public void itObservesTheSourceSequenceOnTheMainUIThread() {
-            OperationObserveFromAndroidComponent.observeFromAndroidComponent(mockObservable, mockFragment).subscribe(mockObserver);
-            verify(mockObservable).observeOn(AndroidSchedulers.mainThread());
-        }
-
-        @Test
-        public void itForwardsOnNextOnCompletedSequenceToTargetObserver() {
-            Observable source = Observable.from(1, 2, 3);
-            OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
-            verify(mockObserver, times(3)).onNext(anyInt());
-            verify(mockObserver).onCompleted();
-            verify(mockObserver, never()).onError(any(Exception.class));
-        }
-
-        @Test
-        public void itForwardsOnErrorToTargetObserver() {
-            final Exception exception = new Exception();
-            Observable source = Observable.error(exception);
-            OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
-            verify(mockObserver).onError(exception);
-            verify(mockObserver, never()).onNext(anyInt());
-            verify(mockObserver, never()).onCompleted();
-        }
-
-        @Test
-        public void itDropsOnNextOnCompletedSequenceIfTargetComponentIsGone() throws Throwable {
-            PublishSubject source = PublishSubject.create();
-
-            final OnSubscribeFragment operator = new OnSubscribeFragment(source, mockFragment);
-            operator.onSubscribe(mockObserver);
-
-            source.onNext(1);
-            releaseComponentRef(operator);
-
-            source.onNext(2);
-            source.onNext(3);
-            source.onCompleted();
-
-            verify(mockObserver).onNext(1);
-            verifyNoMoreInteractions(mockObserver);
-        }
-
-        @Test
-        public void itDropsOnErrorIfTargetComponentIsGone() throws Throwable {
-            PublishSubject source = PublishSubject.create();
-
-            final OnSubscribeFragment operator = new OnSubscribeFragment(source, mockFragment);
-            operator.onSubscribe(mockObserver);
-
-            source.onNext(1);
-            releaseComponentRef(operator);
-
-            source.onError(new Exception());
-
-            verify(mockObserver).onNext(1);
-            verifyNoMoreInteractions(mockObserver);
-        }
-
-        private void releaseComponentRef(OnSubscribeFragment operator) throws NoSuchFieldException, IllegalAccessException {
-            final Field componentRef = operator.getClass().getSuperclass().getDeclaredField("componentRef");
-            componentRef.setAccessible(true);
-            componentRef.set(operator, null);
-        }
-
-        @Test
-        public void itDoesNotForwardOnNextOnCompletedSequenceIfFragmentIsDetached() {
-            PublishSubject source = PublishSubject.create();
-            OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
-
-            source.onNext(1);
-
-            when(mockFragment.isAdded()).thenReturn(false);
-            source.onNext(2);
-            source.onNext(3);
-            source.onCompleted();
-
-            verify(mockObserver).onNext(1);
-            verify(mockObserver, never()).onCompleted();
-        }
-
-        @Test
-        public void itDoesNotForwardOnErrorIfFragmentIsDetached() {
-            PublishSubject source = PublishSubject.create();
-            OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
-
-            source.onNext(1);
-
-            when(mockFragment.isAdded()).thenReturn(false);
-            source.onError(new Exception());
-
-            verify(mockObserver).onNext(1);
-            verify(mockObserver, never()).onError(any(Exception.class));
-        }
-
-        @Test
-        public void itUnsubscribesFromTheSourceSequence() {
-            Subscription underlying = mock(Subscription.class);
-            when(mockObservable.observeOn(AndroidSchedulers.mainThread())).thenReturn(mockObservable);
-            when(mockObservable.subscribe(any(Observer.class))).thenReturn(underlying);
-
-            Subscription sub = OperationObserveFromAndroidComponent.observeFromAndroidComponent(
-                    mockObservable, mockActivity).subscribe(mockObserver);
-            sub.unsubscribe();
-
-            verify(underlying).unsubscribe();
-        }
-    }
 }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java
new file mode 100644
index 0000000000..0f8f81e5e8
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java
@@ -0,0 +1,85 @@
+/**
+ * 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.android.observables;
+
+import static org.mockito.Mockito.verify;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import rx.Observable;
+import rx.Observer;
+import rx.operators.OperationObserveFromAndroidComponent;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Build;
+import android.support.v4.app.FragmentActivity;
+
+import rx.android.observables.AndroidObservable;
+
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class AndroidObservableTest {
+
+    // support library fragments
+    private FragmentActivity fragmentActivity;
+    private android.support.v4.app.Fragment supportFragment;
+
+    // native fragments
+    private Activity activity;
+    private Fragment fragment;
+
+    @Mock
+    private Observer observer;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        supportFragment = new android.support.v4.app.Fragment();
+        fragmentActivity = Robolectric.buildActivity(FragmentActivity.class).create().get();
+        fragmentActivity.getSupportFragmentManager().beginTransaction().add(supportFragment, null).commit();
+
+        fragment = new Fragment();
+        activity = Robolectric.buildActivity(Activity.class).create().get();
+        activity.getFragmentManager().beginTransaction().add(fragment, null).commit();
+    }
+
+    @Test
+    public void itSupportsFragmentsFromTheSupportV4Library() {
+        AndroidObservable.fromFragment(supportFragment, Observable.just("success")).subscribe(observer);
+        verify(observer).onNext("success");
+        verify(observer).onCompleted();
+    }
+
+    @Test
+    public void itSupportsNativeFragments() {
+        AndroidObservable.fromFragment(fragment, Observable.just("success")).subscribe(observer);
+        verify(observer).onNext("success");
+        verify(observer).onCompleted();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void itThrowsIfObjectPassedIsNotAFragment() {
+        AndroidObservable.fromFragment("not a fragment", Observable.never());
+    }
+}
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
new file mode 100644
index 0000000000..14ef2d2790
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
@@ -0,0 +1,213 @@
+/**
+ * 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 static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import static org.junit.Assert.*;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.subjects.PublishSubject;
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Looper;
+import android.util.Log;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class OperationObserveFromAndroidComponentTest {
+
+    @Mock
+    private Observer mockObserver;
+
+    @Mock
+    private Fragment mockFragment;
+
+    @Mock
+    private Activity mockActivity;
+
+    @Mock
+    private Observable mockObservable;
+
+    @Before
+    public void setupMocks() {
+        MockitoAnnotations.initMocks(this);
+        when(mockFragment.isAdded()).thenReturn(true);
+    }
+
+    @Test
+    public void itThrowsIfObserverSubscribesFromBackgroundThread() throws Exception {
+        final Future future = Executors.newSingleThreadExecutor().submit(new Callable() {
+            @Override
+            public Object call() throws Exception {
+                OperationObserveFromAndroidComponent.observeFromAndroidComponent(
+                        mockObservable, mockFragment).subscribe(mockObserver);
+                return null;
+            }
+        });
+        future.get(1, TimeUnit.SECONDS);
+        verify(mockObserver).onError(any(IllegalStateException.class));
+        verifyNoMoreInteractions(mockObserver);
+    }
+
+    @Test
+    public void itObservesTheSourceSequenceOnTheMainUIThread() {
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(mockObservable, mockFragment).subscribe(mockObserver);
+        verify(mockObservable).observeOn(AndroidSchedulers.mainThread());
+    }
+
+    @Test
+    public void itForwardsOnNextOnCompletedSequenceToTargetObserver() {
+        Observable source = Observable.from(1, 2, 3);
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
+        verify(mockObserver, times(3)).onNext(anyInt());
+        verify(mockObserver).onCompleted();
+        verify(mockObserver, never()).onError(any(Exception.class));
+    }
+
+    @Test
+    public void itForwardsOnErrorToTargetObserver() {
+        final Exception exception = new Exception();
+        Observable source = Observable.error(exception);
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
+        verify(mockObserver).onError(exception);
+        verify(mockObserver, never()).onNext(anyInt());
+        verify(mockObserver, never()).onCompleted();
+    }
+
+    @Test
+    public void itDropsOnNextOnCompletedSequenceIfTargetComponentIsGone() throws Throwable {
+        PublishSubject source = PublishSubject.create();
+
+        final Observable.OnSubscribeFunc operator = newOnSubscribeFragmentInstance(source, mockFragment);
+        operator.onSubscribe(mockObserver);
+
+        source.onNext(1);
+        releaseComponentRef(operator);
+
+        source.onNext(2);
+        source.onNext(3);
+        source.onCompleted();
+
+        verify(mockObserver).onNext(1);
+        verifyNoMoreInteractions(mockObserver);
+    }
+
+    @Test
+    public void itDropsOnErrorIfTargetComponentIsGone() throws Throwable {
+        PublishSubject source = PublishSubject.create();
+
+        final Observable.OnSubscribeFunc operator = newOnSubscribeFragmentInstance(source, mockFragment);
+        operator.onSubscribe(mockObserver);
+
+        source.onNext(1);
+        releaseComponentRef(operator);
+
+        source.onError(new Exception());
+
+        verify(mockObserver).onNext(1);
+        verifyNoMoreInteractions(mockObserver);
+    }
+
+    private Observable.OnSubscribeFunc newOnSubscribeFragmentInstance(Observable source, Fragment fragment) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException  {
+        final Class[] klasses = OperationObserveFromAndroidComponent.class.getDeclaredClasses();
+        Class onSubscribeFragmentClass = null;
+        for (Class klass : klasses) {
+            if ("rx.operators.OperationObserveFromAndroidComponent$OnSubscribeFragment".equals(klass.getName())) {
+                onSubscribeFragmentClass = klass;
+                break;
+            }
+        }
+        Constructor constructor = onSubscribeFragmentClass.getDeclaredConstructor(Observable.class, Fragment.class);
+        constructor.setAccessible(true);
+        Object object = constructor.newInstance(source, fragment);
+        return (Observable.OnSubscribeFunc) object;
+    }
+
+    private void releaseComponentRef(Observable.OnSubscribeFunc operator) throws NoSuchFieldException, IllegalAccessException {
+        final Field componentRef = operator.getClass().getSuperclass().getDeclaredField("componentRef");
+        componentRef.setAccessible(true);
+        componentRef.set(operator, null);
+    }
+
+    @Test
+    public void itDoesNotForwardOnNextOnCompletedSequenceIfFragmentIsDetached() {
+        PublishSubject source = PublishSubject.create();
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
+
+        source.onNext(1);
+
+        when(mockFragment.isAdded()).thenReturn(false);
+        source.onNext(2);
+        source.onNext(3);
+        source.onCompleted();
+
+        verify(mockObserver).onNext(1);
+        verify(mockObserver, never()).onCompleted();
+    }
+
+    @Test
+    public void itDoesNotForwardOnErrorIfFragmentIsDetached() {
+        PublishSubject source = PublishSubject.create();
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(mockObserver);
+
+        source.onNext(1);
+
+        when(mockFragment.isAdded()).thenReturn(false);
+        source.onError(new Exception());
+
+        verify(mockObserver).onNext(1);
+        verify(mockObserver, never()).onError(any(Exception.class));
+    }
+
+    @Test
+    public void itUnsubscribesFromTheSourceSequence() {
+        Subscription underlying = mock(Subscription.class);
+        when(mockObservable.observeOn(AndroidSchedulers.mainThread())).thenReturn(mockObservable);
+        when(mockObservable.subscribe(any(Observer.class))).thenReturn(underlying);
+
+        Subscription sub = OperationObserveFromAndroidComponent.observeFromAndroidComponent(
+                mockObservable, mockActivity).subscribe(mockObserver);
+        sub.unsubscribe();
+
+        verify(underlying).unsubscribe();
+    }
+}
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
new file mode 100644
index 0000000000..936ff51dbf
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
@@ -0,0 +1,81 @@
+/**
+ * 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.android.schedulers;
+
+import android.os.Handler;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import rx.Scheduler;
+import rx.Subscription;
+import rx.operators.SafeObservableSubscription;
+import rx.util.functions.Func2;
+
+import java.util.concurrent.TimeUnit;
+
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest=Config.NONE)
+public class HandlerThreadSchedulerTest {
+
+    @Test
+    public void shouldScheduleImmediateActionOnHandlerThread() {
+        final Handler handler = mock(Handler.class);
+        final Object state = new Object();
+        @SuppressWarnings("unchecked")
+        final Func2 action = mock(Func2.class);
+
+        Scheduler scheduler = new HandlerThreadScheduler(handler);
+        scheduler.schedule(state, action);
+
+        // verify that we post to the given Handler
+        ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class);
+        verify(handler).postDelayed(runnable.capture(), eq(0L));
+
+        // verify that the given handler delegates to our action
+        runnable.getValue().run();
+        verify(action).call(scheduler, state);
+    }
+
+    @Test
+    public void shouldScheduleDelayedActionOnHandlerThread() {
+        final Handler handler = mock(Handler.class);
+        final Object state = new Object();
+        @SuppressWarnings("unchecked")
+        final Func2 action = mock(Func2.class);
+
+        Scheduler scheduler = new HandlerThreadScheduler(handler);
+        scheduler.schedule(state, action, 1L, TimeUnit.SECONDS);
+
+        // verify that we post to the given Handler
+        ArgumentCaptor runnable = ArgumentCaptor.forClass(Runnable.class);
+        verify(handler).postDelayed(runnable.capture(), eq(1000L));
+
+        // verify that the given handler delegates to our action
+        runnable.getValue().run();
+        verify(action).call(scheduler, state);
+    }
+}

From 4f9afe8e10e2adb4e0ed42fec6c031540b267fc1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 00:42:51 -0800
Subject: [PATCH 210/441] Version 0.16.1

---
 CHANGES.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index b5e8b36935..5f8f2a6269 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,24 @@
 # RxJava Releases #
 
+### Version 0.16.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.16.1%22)) ###
+
+* [Pull 730](https://github.com/Netflix/RxJava/pull/730) Improve Error Handling and Stacktraces When Unsubscribe Fails
+* [Pull 720](https://github.com/Netflix/RxJava/pull/720) Added `Observable.timeout` wrappers to scala adapter
+* [Pull 731](https://github.com/Netflix/RxJava/pull/731) Fix non-deterministic unit test
+* [Pull 742](https://github.com/Netflix/RxJava/pull/742) Build with Gradle 1.10
+* [Pull 718](https://github.com/Netflix/RxJava/pull/718) Merge overloads
+* [Pull 733](https://github.com/Netflix/RxJava/pull/733) Buffer with Observable boundary
+* [Pull 734](https://github.com/Netflix/RxJava/pull/734) Delay with subscription and item delaying observables
+* [Pull 735](https://github.com/Netflix/RxJava/pull/735) Window with Observable boundary
+* [Pull 736](https://github.com/Netflix/RxJava/pull/736) MergeMap with Iterable and resultSelector overloads
+* [Pull 738](https://github.com/Netflix/RxJava/pull/738) Publish and PublishLast overloads
+* [Pull 739](https://github.com/Netflix/RxJava/pull/739) Debounce with selector
+* [Pull 740](https://github.com/Netflix/RxJava/pull/740) Timeout with selector overloads
+* [Pull 745](https://github.com/Netflix/RxJava/pull/745) Fixed `switch` bug
+* [Pull 741](https://github.com/Netflix/RxJava/pull/741) Zip with iterable, removed old aggregator version and updated tests
+* [Pull 749](https://github.com/Netflix/RxJava/pull/749) Separated Android test code from source
+
+
 ### Version 0.16.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.16.0%22)) ###
 
 

From d892c7fa8b3345be5905e223c53c2a84be1c1c74 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 10:52:24 -0800
Subject: [PATCH 211/441] Version 0.16.1

---
 CHANGES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGES.md b/CHANGES.md
index 5f8f2a6269..527d52ba3c 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -17,6 +17,7 @@
 * [Pull 745](https://github.com/Netflix/RxJava/pull/745) Fixed `switch` bug
 * [Pull 741](https://github.com/Netflix/RxJava/pull/741) Zip with iterable, removed old aggregator version and updated tests
 * [Pull 749](https://github.com/Netflix/RxJava/pull/749) Separated Android test code from source
+* [Pull 732](https://github.com/Netflix/RxJava/pull/732) Ported groupByUntil function to scala-adapter
 
 
 ### Version 0.16.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.16.0%22)) ###

From 76ad85b3f72644aa20f27779823783be065d696d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 22:54:57 -0800
Subject: [PATCH 212/441] Organize Imports and Format Code

- standardizing all source
---
 rxjava-core/src/main/java/rx/Observable.java  | 4360 ++++++++++-------
 .../concurrency/CurrentThreadScheduler.java   |    8 +-
 .../rx/concurrency/ExecutorScheduler.java     |    8 +-
 .../rx/concurrency/ImmediateScheduler.java    |    8 +-
 .../rx/concurrency/NewThreadScheduler.java    |    8 +-
 .../main/java/rx/concurrency/Schedulers.java  |    8 +-
 .../java/rx/concurrency/TestScheduler.java    |    8 +-
 .../src/main/java/rx/joins/ActivePlan0.java   |    5 +-
 .../src/main/java/rx/joins/ActivePlan1.java   |    9 +-
 .../src/main/java/rx/joins/ActivePlan2.java   |   11 +-
 .../src/main/java/rx/joins/ActivePlan3.java   |   17 +-
 .../src/main/java/rx/joins/JoinObserver.java  |    7 +-
 .../src/main/java/rx/joins/JoinObserver1.java |   11 +-
 .../src/main/java/rx/joins/Pattern.java       |    3 +-
 .../src/main/java/rx/joins/Pattern1.java      |   20 +-
 .../src/main/java/rx/joins/Pattern2.java      |   15 +-
 .../src/main/java/rx/joins/Pattern3.java      |   25 +-
 rxjava-core/src/main/java/rx/joins/Plan0.java |    9 +-
 rxjava-core/src/main/java/rx/joins/Plan1.java |   34 +-
 rxjava-core/src/main/java/rx/joins/Plan2.java |   41 +-
 rxjava-core/src/main/java/rx/joins/Plan3.java |   67 +-
 .../rx/observables/BlockingObservable.java    |   94 +-
 .../java/rx/operators/ChunkedOperation.java   |    3 +-
 .../rx/operators/OperationAsObservable.java   |    5 +-
 .../java/rx/operators/OperationAverage.java   |   46 +-
 .../java/rx/operators/OperationBuffer.java    |   44 +-
 .../main/java/rx/operators/OperationCast.java |    8 +-
 .../java/rx/operators/OperationConcat.java    |    2 +-
 .../java/rx/operators/OperationDebounce.java  |   21 +-
 .../rx/operators/OperationDefaultIfEmpty.java |    8 +-
 .../java/rx/operators/OperationDelay.java     |   40 +-
 .../java/rx/operators/OperationDoOnEach.java  |    8 +-
 .../java/rx/operators/OperationFlatMap.java   |   77 +-
 .../rx/operators/OperationGroupByUntil.java   |   88 +-
 .../java/rx/operators/OperationGroupJoin.java |   59 +-
 .../main/java/rx/operators/OperationJoin.java |   44 +-
 .../rx/operators/OperationJoinPatterns.java   |   41 +-
 .../java/rx/operators/OperationLatest.java    |   17 +-
 .../java/rx/operators/OperationMerge.java     |    6 +-
 .../java/rx/operators/OperationMinMax.java    |    6 +-
 .../rx/operators/OperationMostRecent.java     |    4 +-
 .../java/rx/operators/OperationMulticast.java |   22 +-
 .../main/java/rx/operators/OperationNext.java |    6 +-
 .../java/rx/operators/OperationObserveOn.java |    1 -
 .../java/rx/operators/OperationReplay.java    |  258 +-
 .../java/rx/operators/OperationSample.java    |   19 +-
 .../main/java/rx/operators/OperationSkip.java |   27 +-
 .../java/rx/operators/OperationSkipLast.java  |   11 +-
 .../java/rx/operators/OperationSkipUntil.java |   17 +-
 .../main/java/rx/operators/OperationSum.java  |   39 +-
 .../java/rx/operators/OperationSwitch.java    |    6 +-
 .../main/java/rx/operators/OperationTake.java |   33 +-
 .../java/rx/operators/OperationTakeLast.java  |   23 +-
 .../java/rx/operators/OperationTimeout.java   |   25 +-
 .../java/rx/operators/OperationTimer.java     |   53 +-
 .../java/rx/operators/OperationTimestamp.java |    1 +
 .../rx/operators/OperationToIterator.java     |    2 +-
 .../java/rx/operators/OperationToMap.java     |   32 +-
 .../rx/operators/OperationToMultimap.java     |   54 +-
 .../OperationToObservableIterable.java        |    5 +-
 .../operators/OperationToObservableList.java  |    1 -
 .../java/rx/operators/OperationUsing.java     |    8 +-
 .../java/rx/operators/OperationWindow.java    |   14 +-
 .../main/java/rx/operators/OperationZip.java  |  124 +-
 .../main/java/rx/plugins/RxJavaPlugins.java   |    4 +-
 .../java/rx/schedulers/ExecutorScheduler.java |    8 +-
 .../main/java/rx/schedulers/Schedulers.java   |    4 +-
 .../main/java/rx/subjects/ReplaySubject.java  |   10 +-
 .../subjects/SubjectSubscriptionManager.java  |   16 +-
 .../main/java/rx/util/CompositeException.java |    3 +-
 .../main/java/rx/util/functions/Actions.java  |   91 +-
 .../src/test/java/rx/CombineLatestTests.java  |    8 +-
 rxjava-core/src/test/java/rx/ConcatTests.java |    8 +-
 .../src/test/java/rx/CovarianceTest.java      |    8 +-
 rxjava-core/src/test/java/rx/EventStream.java |    8 +-
 .../src/test/java/rx/GroupByTests.java        |    8 +-
 .../src/test/java/rx/IntervalDemo.java        |    8 +-
 rxjava-core/src/test/java/rx/MergeTests.java  |    8 +-
 .../src/test/java/rx/ObservableTests.java     |   11 +-
 .../test/java/rx/ObservableWindowTests.java   |   10 +-
 rxjava-core/src/test/java/rx/ReduceTests.java |    8 +-
 .../src/test/java/rx/RefCountTests.java       |    8 +-
 rxjava-core/src/test/java/rx/ScanTests.java   |    8 +-
 .../src/test/java/rx/StartWithTests.java      |    8 +-
 .../src/test/java/rx/ThrottleFirstTests.java  |    8 +-
 .../src/test/java/rx/ThrottleLastTests.java   |    8 +-
 .../java/rx/ThrottleWithTimeoutTests.java     |    8 +-
 .../src/test/java/rx/TimeoutTests.java        |    8 +-
 rxjava-core/src/test/java/rx/ZipTests.java    |    8 +-
 .../observables/BlockingObservableTest.java   |   53 +-
 .../java/rx/operators/OperationAllTest.java   |    8 +-
 .../java/rx/operators/OperationAnyTest.java   |    8 +-
 .../rx/operators/OperationAverageTest.java    |   84 +-
 .../rx/operators/OperationBufferTest.java     |  100 +-
 .../java/rx/operators/OperationCacheTest.java |    8 +-
 .../java/rx/operators/OperationCastTest.java  |    8 +-
 .../operators/OperationCombineLatestTest.java |  106 +-
 .../rx/operators/OperationConcatTest.java     |   20 +-
 .../rx/operators/OperationDebounceTest.java   |   45 +-
 .../OperationDefaultIfEmptyTest.java          |    8 +-
 .../java/rx/operators/OperationDeferTest.java |    8 +-
 .../java/rx/operators/OperationDelayTest.java |  131 +-
 .../operators/OperationDematerializeTest.java |    8 +-
 .../rx/operators/OperationDistinctTest.java   |    8 +-
 .../OperationDistinctUntilChangedTest.java    |    8 +-
 .../rx/operators/OperationDoOnEachTest.java   |   32 +-
 .../rx/operators/OperationElementAtTest.java  |    8 +-
 .../rx/operators/OperationFilterTest.java     |    8 +-
 .../rx/operators/OperationFinallyTest.java    |    8 +-
 .../OperationFirstOrDefaultTest.java          |    8 +-
 .../rx/operators/OperationFlatMapTest.java    |  107 +-
 .../rx/operators/OperationGroupByTest.java    |    8 +-
 .../operators/OperationGroupByUntilTest.java  |  157 +-
 .../rx/operators/OperationGroupJoinTest.java  |  145 +-
 .../rx/operators/OperationIntervalTest.java   |   10 +-
 .../java/rx/operators/OperationJoinTest.java  |  143 +-
 .../java/rx/operators/OperationJoinsTest.java |  192 +-
 .../java/rx/operators/OperationLastTest.java  |    8 +-
 .../rx/operators/OperationLatestTest.java     |  129 +-
 .../java/rx/operators/OperationMapTest.java   |   27 +-
 .../operators/OperationMaterializeTest.java   |    8 +-
 .../OperationMergeDelayErrorTest.java         |    8 +-
 .../java/rx/operators/OperationMergeTest.java |   10 +-
 .../rx/operators/OperationMinMaxTest.java     |   17 +-
 .../rx/operators/OperationMostRecentTest.java |   28 +-
 .../rx/operators/OperationMulticastTest.java  |    8 +-
 .../java/rx/operators/OperationNextTest.java  |   24 +-
 .../rx/operators/OperationObserveOnTest.java  |    2 +-
 ...ationOnErrorResumeNextViaFunctionTest.java |    8 +-
 ...ionOnErrorResumeNextViaObservableTest.java |    8 +-
 .../operators/OperationOnErrorReturnTest.java |    8 +-
 ...nExceptionResumeNextViaObservableTest.java |    8 +-
 .../rx/operators/OperationParallelTest.java   |    8 +-
 .../rx/operators/OperationReduceTest.java     |   47 +-
 .../rx/operators/OperationReplayTest.java     |  136 +-
 .../java/rx/operators/OperationRetryTest.java |    8 +-
 .../rx/operators/OperationSampleTest.java     |   78 +-
 .../java/rx/operators/OperationScanTest.java  |    8 +-
 .../OperationSequenceEqualTests.java          |    6 +-
 .../rx/operators/OperationSingleTest.java     |    6 +-
 .../rx/operators/OperationSkipLastTest.java   |   67 +-
 .../java/rx/operators/OperationSkipTest.java  |   95 +-
 .../rx/operators/OperationSkipUntilTest.java  |   65 +-
 .../rx/operators/OperationSkipWhileTest.java  |    8 +-
 .../operators/OperationSubscribeOnTest.java   |    8 +-
 .../java/rx/operators/OperationSumTest.java   |   84 +-
 .../rx/operators/OperationSwitchTest.java     |    8 +-
 .../operators/OperationSynchronizeTest.java   |    8 +-
 .../rx/operators/OperationTakeLastTest.java   |   92 +-
 .../java/rx/operators/OperationTakeTest.java  |   71 +-
 .../rx/operators/OperationTakeUntilTest.java  |    8 +-
 .../rx/operators/OperationTakeWhileTest.java  |    8 +-
 .../operators/OperationThrottleFirstTest.java |    8 +-
 .../operators/OperationTimeIntervalTest.java  |    8 +-
 .../rx/operators/OperationTimeoutTest.java    |   94 +-
 .../java/rx/operators/OperationTimerTest.java |   19 +-
 .../rx/operators/OperationTimestampTest.java  |   31 +-
 .../rx/operators/OperationToFutureTest.java   |    8 +-
 .../rx/operators/OperationToIteratorTest.java |    8 +-
 .../java/rx/operators/OperationToMapTest.java |   67 +-
 .../rx/operators/OperationToMultimapTest.java |   85 +-
 .../OperationToObservableFutureTest.java      |    8 +-
 .../OperationToObservableIterableTest.java    |   10 +-
 .../OperationToObservableListTest.java        |    8 +-
 .../OperationToObservableSortedListTest.java  |    8 +-
 .../java/rx/operators/OperationUsingTest.java |   18 +-
 .../rx/operators/OperationWindowTest.java     |   86 +-
 .../java/rx/operators/OperationZipTest.java   |  365 +-
 .../operators/OperationZipTestCompletion.java |  162 +-
 .../java/rx/operators/OperatorTesterTest.java |    8 +-
 .../SafeObservableSubscriptionTest.java       |    8 +-
 .../operators/SynchronizedObserverTest.java   |    8 +-
 .../test/java/rx/operators/TakeWhileTest.java |    8 +-
 .../operators/TimeIntervalObserverTest.java   |    8 +-
 .../rx/schedulers/AbstractSchedulerTests.java |    1 +
 .../java/rx/subjects/AsyncSubjectTest.java    |    5 +-
 .../java/rx/subjects/BehaviorSubjectTest.java |    3 +-
 .../java/rx/subjects/PublishSubjectTest.java  |    2 -
 .../java/rx/subjects/ReplaySubjectTest.java   |    6 +-
 .../CompositeSubscriptionTest.java            |    5 +-
 .../RefCountSubscriptionTest.java             |   39 +-
 .../SerialSubscriptionTests.java              |   15 +-
 .../rx/subscriptions/SubscriptionsTest.java   |    8 +-
 .../test/java/rx/util/AssertObservable.java   |   14 +-
 .../java/rx/util/AssertObservableTest.java    |    8 +-
 .../src/test/java/rx/util/RangeTest.java      |    8 +-
 186 files changed, 5709 insertions(+), 4364 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c469e8473f..9eae69b528 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -152,7 +152,8 @@
  * For more information see the
  * RxJava Wiki
  * 
- * @param  the type of the item emitted by the Observable
+ * @param 
+ *            the type of the item emitted by the Observable
  */
 public class Observable {
 
@@ -164,8 +165,7 @@ public class Observable {
     private final OnSubscribeFunc onSubscribe;
 
     /**
-     * Function interface for work to be performed when an {@link Observable}
-     * is subscribed to via {@link Observable#subscribe(Observer)}
+     * Function interface for work to be performed when an {@link Observable} is subscribed to via {@link Observable#subscribe(Observer)}
      * 
      * @param 
      */
@@ -182,8 +182,8 @@ public static interface OnSubscribeFunc extends Function {
      * 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
+     * @param onSubscribe
+     *            {@link OnSubscribeFunc} to be executed when {@link #subscribe(Observer)} is called
      */
     protected Observable(OnSubscribeFunc onSubscribe) {
         this.onSubscribe = onSubscribe;
@@ -198,12 +198,11 @@ protected Observable(OnSubscribeFunc onSubscribe) {
      * A typical implementation of {@code subscribe} does the following:
      * 
      
      * 
    1. It stores a reference to the Observer in a collection object, such as
-     *     a {@code List} object.
      2. 
+     * a {@code List} object.
      * 
    2. 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.
      3. 
+     * 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
@@ -214,13 +213,13 @@ protected Observable(OnSubscribeFunc onSubscribe) {
      * 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
+     * @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}
+     * @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
@@ -279,12 +278,11 @@ public Subscription subscribe(Observer observer) {
      * A typical implementation of {@code subscribe} does the following:
      * 
      
      * 
    1. It stores a reference to the Observer in a collection object, such as
-     *     a {@code List} object.
      2. 
+     * a {@code List} object.
      * 
    2. 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.
      3. 
+     * 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
@@ -295,14 +293,16 @@ public Subscription subscribe(Observer observer) {
      * For more information see the
      * RxJava Wiki
      * 
-     * @param observer the Observer
-     * @param scheduler the {@link Scheduler} on which Observers subscribe to
-     *                  the Observable
+     * @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}
+     * @throws IllegalArgumentException
+     *             if an argument to {@code subscribe()} is {@code null}
      */
     public Subscription subscribe(Observer observer, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(observer);
@@ -322,8 +322,8 @@ private Subscription protectivelyWrapAndSubscribe(Observer o) {
 
     /**
      * Subscribe and ignore all events.
-     *  
-     * @return 
+     * 
+     * @return
      */
     public Subscription subscribe() {
         return protectivelyWrapAndSubscribe(new Observer() {
@@ -345,13 +345,13 @@ public void onNext(T args) {
 
         });
     }
-    
+
     /**
      * An {@link Observer} must call an Observable's {@code subscribe} method
      * in order to receive items and notifications from the Observable.
      * 
      * @param onNext
-     * @return 
+     * @return
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public Subscription subscribe(final Action1 onNext) {
@@ -516,23 +516,24 @@ public Subscription subscribe(final Action1 onNext, final Action1 asObservable() {
-         return create(new OperationAsObservable(this));
-     }
+     * Hides the identity of this observable.
+     * 
+     * @return an Observable hiding the identity of this Observable.
+     */
+    public Observable asObservable() {
+        return create(new OperationAsObservable(this));
+    }
 
     /**
      * 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
+     * @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}
+     *         source Observable to push results into the specified {@link Subject}
      * @see RxJava Wiki: Observable.publish() and Observable.multicast()
      */
     public  ConnectableObservable multicast(Subject subject) {
@@ -540,13 +541,15 @@ public  ConnectableObservable multicast(Subject su
     }
 
     /**
-     * Returns an observable sequence that contains the elements of a sequence 
+     * Returns an observable sequence that contains the elements of a sequence
      * produced by multicasting the source sequence within a selector function.
      * 
-     * @param subjectFactory the subject factory
-     * @param selector the selector function which can use the multicasted 
-     *                 source sequence subject to the policies enforced by the 
-     *                 created subject
+     * @param subjectFactory
+     *            the subject factory
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            source sequence subject to the policies enforced by the
+     *            created subject
      * @return the Observable sequence that contains the elements of a sequence
      *         produced by multicasting the source sequence within a selector
      *         function
@@ -554,7 +557,7 @@ public  ConnectableObservable multicast(Subject su
      * @see MSDN: Observable.Multicast
      */
     public  Observable multicast(
-            final Func0> subjectFactory, 
+            final Func0> subjectFactory,
             final Func1, ? extends Observable> selector) {
         return OperationMulticast.multicast(this, subjectFactory, selector);
     }
@@ -564,7 +567,8 @@ public  Observable multicast(
      * 
      * This Observable is useful primarily for testing purposes.
      * 
-     * @param  the type of item emitted by the Observable
+     * @param 
+     *            the type of item emitted by the Observable
      */
     private static class NeverObservable extends Observable {
         public NeverObservable() {
@@ -580,10 +584,10 @@ public Subscription onSubscribe(Observer t1) {
     }
 
     /**
-     * An Observable that invokes {@link Observer#onError onError} when the
-     * {@link Observer} subscribes to it.
+     * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
      * 
-     * @param  the type of item emitted by the Observable
+     * @param 
+     *            the type of item emitted by the Observable
      */
     private static class ThrowObservable extends Observable {
 
@@ -591,10 +595,10 @@ public ThrowObservable(final Throwable exception) {
             super(new OnSubscribeFunc() {
 
                 /**
-                 * Accepts an {@link Observer} and calls its
-                 * {@link Observer#onError onError} method.
+                 * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.
                  * 
-                 * @param observer an {@link Observer} of this Observable
+                 * @param observer
+                 *            an {@link Observer} of this Observable
                  * @return a reference to the subscription
                  */
                 @Override
@@ -609,15 +613,12 @@ public Subscription onSubscribe(Observer observer) {
     }
 
     /**
-     * Creates an Observable that will execute the given function when an
-     * {@link Observer} subscribes to it.
+     * 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.
+     * 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
@@ -626,11 +627,11 @@ public Subscription onSubscribe(Observer observer) {
      * 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 cancel the subscription
+     * @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 cancel the subscription
      * @return an Observable that, when an {@link Observer} subscribes to it,
      *         will execute the given function
      * @see RxJava Wiki: create()
@@ -646,10 +647,10 @@ public static  Observable create(OnSubscribeFunc func) {
      * 
    
      * 
      * 
-     * @param  the type of the items (ostensibly) emitted by the Observable
+     * @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
+     *         immediately invokes the {@link Observer}'s {@link Observer#onCompleted() onCompleted} method
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty
      */
@@ -664,12 +665,12 @@ public static  Observable empty() {
      * 
    
      * 
      * 
-     * @param scheduler the scheduler to call the
-                        {@link Observer#onCompleted onCompleted} method
-     * @param  the type of the items (ostensibly) emitted by the Observable
+     * @param scheduler
+     *            the scheduler to call the {@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 with the
+     *         immediately invokes the {@link Observer}'s {@link Observer#onCompleted() onCompleted} method with the
      *         specified scheduler
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty Method (IScheduler)
@@ -679,16 +680,16 @@ public static  Observable empty(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s
-     * {@link Observer#onError onError} method when the Observer subscribes to
+     * 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
+     * @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
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
@@ -698,17 +699,17 @@ public static  Observable error(Throwable exception) {
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s
-     * {@link Observer#onError onError} method with the specified scheduler.
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method with the specified scheduler.
      * 
    
      * 
      * 
-     * @param exception the particular error to report
-     * @param scheduler the scheduler to call the
-     *                  {@link Observer#onError onError} method
-     * @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 with the specified
+     * @param exception
+     *            the particular error to report
+     * @param scheduler
+     *            the scheduler to call the {@link Observer#onError onError} method
+     * @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 with the specified
      *         scheduler
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
@@ -722,16 +723,16 @@ public static  Observable error(Throwable exception, Scheduler scheduler)
      * 
    
      * 
      * 
    
-     * Note: the entire iterable sequence is immediately emitted each time an
-     * {@link Observer} subscribes. Since this occurs before the
-     * {@link Subscription} is returned, it is not possible to unsubscribe from
+     * Note: the entire iterable sequence is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is 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
+     * @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
+     * @return an Observable that emits each item in the source {@link Iterable} sequence
      * @see RxJava Wiki: from()
      */
     public static  Observable from(Iterable iterable) {
@@ -744,12 +745,14 @@ public static  Observable from(Iterable iterable) {
      * 
    
      * 
      * 
-     * @param iterable the source {@link Iterable} sequence
-     * @param scheduler the scheduler to emit the items of the iterable
-     * @param  the type of items in the {@link Iterable} sequence and the
+     * @param iterable
+     *            the source {@link Iterable} sequence
+     * @param scheduler
+     *            the scheduler to emit the items of the iterable
+     * @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 with the specified scheduler
+     * @return an Observable that emits each item in the source {@link Iterable} sequence with the specified scheduler
      * @see RxJava Wiki: from()
      * @see MSDN: Observable.ToObservable
      */
@@ -762,13 +765,13 @@ public static  Observable from(Iterable iterable, Scheduler s
      * 
    
      * 
      * 
    
-     * Note: the entire array is immediately emitted each time an
-     * {@link Observer} subscribes. Since this occurs before the
-     * {@link Subscription} is returned, it is not possible to unsubscribe from
+     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
      * the sequence before it completes.
      * 
-     * @param items the source array
-     * @param  the type of items in the Array and the type of items to be
+     * @param items
+     *            the source array
+     * @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
      * @see RxJava Wiki: from()
@@ -782,14 +785,15 @@ public static  Observable from(T[] items) {
      * 
    
      * 
      * 
    
-     * Note: the entire array is immediately emitted each time an
-     * {@link Observer} subscribes. Since this occurs before the
-     * {@link Subscription} is returned, it is not possible to unsubscribe from
+     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
      * the sequence before it completes.
-     *
-     * @param items the source array
-     * @param scheduler the scheduler to emit the items of the array
-     * @param  the type of items in the Array and the type of items to be
+     * 
+     * @param items
+     *            the source array
+     * @param scheduler
+     *            the scheduler to emit the items of the array
+     * @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
      * @see RxJava Wiki: from()
@@ -803,13 +807,14 @@ public static  Observable from(T[] items, Scheduler scheduler) {
      * 
    
      * 
      * 
    
-     * Note: the item is immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the item is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 the item
-     * @param  the type of the item, and the type of the item to be
+     * @param t1
+     *            the item
+     * @param 
+     *            the type of the item, and the type of the item to be
      *            emitted by the resulting Observable
      * @return an Observable that emits the item
      * @see RxJava Wiki: from()
@@ -825,14 +830,16 @@ public static  Observable from(T t1) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -850,15 +857,18 @@ public static  Observable from(T t1, T t2) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
-     *
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param  the type of items, and the type of items to be emitted by the
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -876,16 +886,20 @@ public static  Observable from(T t1, T t2, T t3) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -903,17 +917,22 @@ public static  Observable from(T t1, T t2, T t3, T t4) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -931,18 +950,24 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param t6 sixth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -960,19 +985,26 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param t6 sixth item
-     * @param t7 seventh item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -990,20 +1022,28 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param t6 sixth item
-     * @param t7 seventh item
-     * @param t8 eighth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -1021,21 +1061,30 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * 
    
      * 
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer}
-     * subscribes. Since this occurs before the {@link Subscription} is
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
      * returned, it is not possible to unsubscribe from the sequence before it
      * completes.
      * 
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param t6 sixth item
-     * @param t7 seventh item
-     * @param t8 eighth item
-     * @param t9 ninth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param t9
+     *            ninth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -1053,17 +1102,29 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * 
    
      * 
      * 
    
-     * @param t1 first item
-     * @param t2 second item
-     * @param t3 third item
-     * @param t4 fourth item
-     * @param t5 fifth item
-     * @param t6 sixth item
-     * @param t7 seventh item
-     * @param t8 eighth item
-     * @param t9 ninth item
-     * @param t10 tenth item
-     * @param  the type of items, and the type of items to be emitted by the
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param t9
+     *            ninth item
+     * @param t10
+     *            tenth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
      *            resulting Observable
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
@@ -1075,15 +1136,18 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     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.
      * 
    
      * 
      * 
    
-     * @param start the value of the first Integer in the sequence
-     * @param count the number of sequential Integers to generate
+     * 
+     * @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 RxJava Wiki: range()
      * @see MSDN: Observable.Range
@@ -1097,10 +1161,13 @@ public static Observable range(int start, int count) {
      * specified range with the specified scheduler.
      * 
    
      * 
-     *
-     * @param start the value of the first Integer in the sequence
-     * @param count the number of sequential Integers to generate
-     * @param scheduler the scheduler to run the generator loop on
+     * 
+     * @param start
+     *            the value of the first Integer in the sequence
+     * @param count
+     *            the number of sequential Integers to generate
+     * @param scheduler
+     *            the scheduler to run the generator loop on
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
      * @see MSDN: Observable.Range
@@ -1113,7 +1180,7 @@ public static Observable range(int start, int count, Scheduler schedule
      * Repeats the observable sequence indefinitely.
      * 
    
      * 
-     *
+     * 
      * @return an Observable that emits the items emitted by the source
      *         Observable repeatedly and in sequence
      * @see RxJava Wiki: repeat()
@@ -1128,7 +1195,8 @@ public Observable repeat() {
      * 
    
      * 
      * 
-     * @param scheduler the scheduler to send the values on.
+     * @param scheduler
+     *            the scheduler to send the values on.
      * @return an Observable that emits the items emitted by the source
      *         Observable repeatedly and in sequence
      * @see RxJava Wiki: repeat()
@@ -1150,10 +1218,12 @@ public Observable repeat(Scheduler scheduler) {
      * 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
+     * @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
      * @see RxJava Wiki: defer()
@@ -1176,8 +1246,10 @@ public static  Observable defer(Func0> o
      * while the just() method converts an Iterable into an
      * Observable that emits the entire Iterable as a single item.
      * 
-     * @param value the item to emit
-     * @param  the type of that item
+     * @param value
+     *            the item to emit
+     * @param 
+     *            the type of that item
      * @return an Observable that emits a single item and then completes
      * @see RxJava Wiki: just()
      * @deprecated Use {@link #from(T)}
@@ -1195,9 +1267,12 @@ public static  Observable just(T value) {
      * 
    
      * This is a scheduler version of {@link Observable#just(Object)}.
      * 
-     * @param value the item to emit
-     * @param  the type of that item
-     * @param scheduler the scheduler to emit the single item on
+     * @param value
+     *            the item to emit
+     * @param 
+     *            the type of that item
+     * @param scheduler
+     *            the scheduler to emit the single item on
      * @return an Observable that emits a single item and then completes, on a
      *         specified scheduler
      * @see RxJava Wiki: just()
@@ -1217,10 +1292,10 @@ public static  Observable just(T value, Scheduler scheduler) {
      * 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
+     * @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
+     *         the items emitted by the Observables emitted by the {@code source} Observable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1237,8 +1312,10 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
@@ -1257,9 +1334,12 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1278,10 +1358,14 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1300,11 +1384,16 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1323,12 +1412,18 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1347,13 +1442,20 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1372,14 +1474,22 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1398,15 +1508,24 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
@@ -1426,11 +1545,12 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
@@ -1447,7 +1567,8 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
@@ -1466,8 +1587,10 @@ public static  Observable merge(Iterable
      * You can combine the items emitted by multiple Observables so that they
      * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences the Observable Iterable
-     * @param maxConcurrent the maximum number of Observables being subscribed to concurrently
+     * @param sequences
+     *            the Observable Iterable
+     * @param maxConcurrent
+     *            the maximum number of Observables being subscribed to concurrently
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the Observables in the Iterable
      * @throw IllegalArgumentException if maxConcurrent <= 0
@@ -1487,9 +1610,12 @@ public static  Observable merge(Iterable
      * You can combine the items emitted by multiple Observables so that they
      * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences the Observable Iterable
-     * @param maxConcurrent the maximum number of Observables being subscribed to concurrently
-     * @param scheduler the scheduler to traversal the Observable array on
+     * @param sequences
+     *            the Observable Iterable
+     * @param maxConcurrent
+     *            the maximum number of Observables being subscribed to concurrently
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the Observables in the Iterable
      * @throw IllegalArgumentException if maxConcurrent <= 0
@@ -1508,8 +1634,10 @@ public static  Observable merge(Iterable
      * You can combine the items emitted by multiple Observables so that they
      * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences the Observable Iterable
-     * @param scheduler the scheduler to traversal the Observable array on
+     * @param sequences
+     *            the Observable Iterable
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the Observables in the Iterable
      * @see RxJava Wiki: merge()
@@ -1527,7 +1655,8 @@ public static  Observable merge(Iterable
      * You can combine the items emitted by multiple Observables so that they
      * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences the Observable array
+     * @param sequences
+     *            the Observable array
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the Observables in the array
      * @see RxJava Wiki: merge()
@@ -1545,8 +1674,10 @@ public static  Observable merge(Observable[] sequences) {
      * You can combine the items emitted by multiple Observables so that they
      * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences the Observable array
-     * @param scheduler the scheduler to traversal the Observable array on
+     * @param sequences
+     *            the Observable array
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
      * @return an Observable that emits items that are the result of flattening
      *         the items emitted by the Observables in the array
      * @see RxJava Wiki: merge()
@@ -1562,7 +1693,8 @@ public static  Observable merge(Observable[] sequences, Sched
      * 
    
      * 
      * 
-     * @param observables an Observable that emits Observables
+     * @param observables
+     *            an Observable that emits 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
@@ -1579,8 +1711,10 @@ public static  Observable concat(Observable
      * 
      * 
-     * @param t1 an Observable to be concatenated
-     * @param t2 an Observable to be concatenated
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            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
@@ -1599,9 +1733,12 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @param t1 an Observable to be concatenated
-     * @param t2 an Observable to be concatenated
-     * @param t3 an Observable to be concatenated
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            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
@@ -1620,10 +1757,14 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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 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
@@ -1642,11 +1783,16 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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 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
@@ -1665,12 +1811,18 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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 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
@@ -1689,13 +1841,20 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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 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
@@ -1714,14 +1873,22 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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 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
@@ -1740,15 +1907,24 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
-     * @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
+     * @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
@@ -1763,25 +1939,23 @@ public static  Observable concat(Observable t1, Observable
      * 
      * 
    
-     * Even if multiple merged Observables send {@code onError} notifications,
-     * {@code mergeDelayError} will only invoke the {@code onError} method of
+     * 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
+     * @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
+     *         the items emitted by the Observables emitted by the {@code source} Observable
      * @see RxJava Wiki: mergeDelayError()
      * @see MSDN: Observable.Merge
      */
@@ -1791,23 +1965,23 @@ public static  Observable mergeDelayError(Observable
      * 
      * 
    
-     * Even if multiple merged Observables send {@code onError} notifications,
-     * {@code mergeDelayError} will only invoke the {@code onError} method of
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1820,25 +1994,26 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
-     * {@link Observer#onError onError}, {@code mergeDelayError} will refrain
+     * This behaves like {@link #merge(Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1851,27 +2026,28 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like
-     * {@link #merge(Observable, Observable, Observable, Observable)} except
-     * that if any of the merged Observables notify of an error via
-     * {@link Observer#onError onError}, {@code mergeDelayError} will refrain
+     * This behaves like {@link #merge(Observable, Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1884,27 +2060,30 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
-     * {@link Observer#onError onError}, {@code mergeDelayError} will refrain
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1917,28 +2096,32 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1951,29 +2134,34 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -1986,30 +2174,36 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
-     * {@link Observer#onError onError}, {@code mergeDelayError} will refrain
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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
+     * 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 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 RxJava Wiki: mergeDelayError()
@@ -2022,31 +2216,38 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable)}
-     * except that if any of the merged Observables notify of an error via
-     * {@link Observer#onError onError}, {@code mergeDelayError} will refrain
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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
+     * 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
+     * @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 RxJava Wiki: mergeDelayError()
@@ -2059,14 +2260,14 @@ public static  Observable mergeDelayError(Observable t1, Obse
     }
 
     /**
-     * Returns an Observable that never sends any items or notifications to an
-     * {@link Observer}.
+     * 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
+     * @param 
+     *            the type of items (not) emitted by the Observable
      * @return an Observable that never emits any items or sends any
      *         notifications to an {@link Observer}
      * @see RxJava Wiki: never()
@@ -2082,7 +2283,8 @@ public static  Observable never() {
      * 
    
      * 
      * 
-     * @param sequenceOfSequences the source Observable that emits Observables
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
      * @return an Observable that emits only the items emitted by the Observable
      *         most recently emitted by the source Observable
      * @see RxJava Wiki: switchOnNext()
@@ -2100,7 +2302,8 @@ public static  Observable switchDo(Observable
      * 
      * 
-     * @param sequenceOfSequences the source Observable that emits Observables
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
      * @return an Observable that emits only the items emitted by the Observable
      *         most recently emitted by the source Observable
      * @see RxJava Wiki: switchOnNext()
@@ -2108,7 +2311,7 @@ public static  Observable switchDo(Observable Observable switchOnNext(Observable> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
-    
+
     /**
      * Given an Observable that emits Observables, returns an Observable that
      * emits the items emitted by the most recently emitted of those
@@ -2116,7 +2319,8 @@ public static  Observable switchOnNext(Observable
      * 
      * 
-     * @param sequenceOfSequences the source Observable that emits Observables
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
      * @return an Observable that emits only the items emitted by the Observable
      *         most recently emitted by the source Observable
      * @see RxJava Wiki: switchOnNext()
@@ -2126,25 +2330,20 @@ public static  Observable switchLatest(Observable
      * 
      * 
    
-     * A well-behaved Observable does not interleave its invocations of the
-     * {@link Observer#onNext onNext}, {@link Observer#onCompleted onCompleted},
+     * 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.
+     * 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.
      * 
      * @return an Observable that is a chronologically well-behaved version of
-     *         the source Observable, and that synchronously notifies its
-     *         {@link Observer}s
+     *         the source Observable, and that synchronously notifies its {@link Observer}s
      * @see RxJava Wiki: synchronize()
      */
     public Observable synchronize() {
@@ -2159,19 +2358,16 @@ public Observable synchronize() {
      * 
    
      * 
      * 
    
-     * A well-behaved Observable does not interleave its invocations of the
-     * {@link Observer#onNext onNext}, {@link Observer#onCompleted onCompleted},
+     * 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.
+     * 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 lock the lock object to synchronize each observer call on
+     * @param lock
+     *            the lock object to synchronize each observer call on
      * @return an Observable that is a chronologically well-behaved version of
-     *         the source Observable, and that synchronously notifies its
-     *         {@link Observer}s
+     *         the source Observable, and that synchronously notifies its {@link Observer}s
      * @see RxJava Wiki: synchronize()
      */
     public Observable synchronize(Object lock) {
@@ -2192,8 +2388,10 @@ public static  Observable synchronize(Observable source) {
      * 
    
      * 
      * 
-     * @param interval interval size in time units (see below)
-     * @param unit time units to use for the interval size
+     * @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 RxJava Wiki: interval()
      * @see MSDN: Observable.Interval
@@ -2208,9 +2406,12 @@ public static Observable interval(long interval, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @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
+     * @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 RxJava Wiki: interval()
      * @see MSDN: Observable.Interval
@@ -2225,8 +2426,10 @@ public static Observable interval(long interval, TimeUnit unit, Scheduler
      * 
    
      * 
      * 
-     * @param delay the initial delay before emitting a single 0L
-     * @param unit time units to use for the interval size
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for the interval size
      * @see RxJava wiki: timer()
      */
     public static Observable timer(long delay, TimeUnit unit) {
@@ -2239,26 +2442,32 @@ public static Observable timer(long delay, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param delay the initial delay before emitting a single 0L
-     * @param unit time units to use for the interval size
-     * @param scheduler the scheduler to use for scheduling the item
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for the interval size
+     * @param scheduler
+     *            the scheduler to use for scheduling the item
      * @see RxJava wiki: timer()
      */
     public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTimer.TimerOnce(delay, unit, scheduler));
     }
-    
+
     /**
      * Return an Observable which emits a 0L after the {@code initialDelay} and
      * ever increasing numbers after each {@code period}.
      * 
    
      * 
      * 
-     * @param initialDelay the initial delay time to wait before emitting the
-     *                     first value of 0L
-     * @param period the time period after emitting the subsequent numbers
-     * @param unit the time unit for both initialDelay and
-     *             period
+     * @param initialDelay
+     *            the initial delay time to wait before emitting the
+     *            first value of 0L
+     * @param period
+     *            the time period after emitting the subsequent numbers
+     * @param unit
+     *            the time unit for both initialDelay and
+     *            period
      * @return an Observable which emits a 0L after the {@code initialDelay} and
      *         ever increasing numbers after each {@code period}
      * @see RxJava Wiki: timer()
@@ -2267,7 +2476,7 @@ public static Observable timer(long delay, TimeUnit unit, Scheduler schedu
     public static Observable timer(long initialDelay, long period, TimeUnit unit) {
         return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation());
     }
-    
+
     /**
      * Return an Observable which emits a 0L after the {@code initialDelay} and
      * ever increasing numbers after each {@code period} while running on the
@@ -2275,13 +2484,17 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
      * 
    
      * 
      * 
-     * @param initialDelay the initial delay time to wait before emitting the
-     *                     first value of 0L
-     * @param period the time period after emitting the subsequent numbers
-     * @param unit the time unit for both initialDelay and
-     *             period
-     * @param scheduler the scheduler on which the waiting happens and value
-     *                  emissions run
+     * @param initialDelay
+     *            the initial delay time to wait before emitting the
+     *            first value of 0L
+     * @param period
+     *            the time period after emitting the subsequent numbers
+     * @param unit
+     *            the time unit for both initialDelay and
+     *            period
+     * @param scheduler
+     *            the scheduler on which the waiting happens and value
+     *            emissions run
      * @return an Observable that emits a 0L after the {@code initialDelay} and
      *         ever increasing numbers after each {@code period} while running
      *         on the given {@code scheduler}
@@ -2297,28 +2510,35 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
      * 
    
      * Note: onError event is immediately propagated.
      * 
-     * @param  the item delay value type (ignored)
-     * @param itemDelay function that returns an Observable for each source item which is
-     *                  then used for delaying that particular item until the Observable
-     *                  fires its first onNext event.
+     * @param 
+     *            the item delay value type (ignored)
+     * @param itemDelay
+     *            function that returns an Observable for each source item which is
+     *            then used for delaying that particular item until the Observable
+     *            fires its first onNext event.
      * @return an Observable which delays the events via another Observable on a per item-basis.
      */
     public  Observable delay(Func1> itemDelay) {
         return create(OperationDelay.delay(this, itemDelay));
     }
+
     /**
      * Create an Observable which delays the subscription and events via another Observables on a per item-basis.
      * 
    
      * Note: onError event is immediately propagated.
      * 
-     * @param  the subscription delay value type (ignored)
-     * @param  the item delay value type (ignored)
-     * @param subscriptionDelay function that returns an Observable which will trigger
-     *                          the subscription to the source observable once it fires an
-     *                          onNext event.
-     * @param itemDelay function that returns an Observable for each source item which is
-     *                  then used for delaying that particular item until the Observable
-     *                  fires its first onNext event.
+     * @param 
+     *            the subscription delay value type (ignored)
+     * @param 
+     *            the item delay value type (ignored)
+     * @param subscriptionDelay
+     *            function that returns an Observable which will trigger
+     *            the subscription to the source observable once it fires an
+     *            onNext event.
+     * @param itemDelay
+     *            function that returns an Observable for each source item which is
+     *            then used for delaying that particular item until the Observable
+     *            fires its first onNext event.
      * @return an Observable which delays the events via another Observable on a per item-basis.
      */
     public  Observable delay(
@@ -2326,16 +2546,18 @@ public  Observable delay(
             Func1> itemDelay) {
         return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
     }
-    
+
     /**
      * Returns an Observable that emits the items emitted by the source
      * Observable shifted forward in time by a specified delay. Error
      * notifications from the source Observable are not delayed.
      * 
    
      * 
-     *
-     * @param delay the delay to shift the source by
-     * @param unit the {@link TimeUnit} in which period is defined
+     * 
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            the {@link TimeUnit} in which period is defined
      * @return the source Observable, but shifted by the specified delay
      * @see RxJava Wiki: delay()
      * @see MSDN: Observable.Delay
@@ -2350,10 +2572,13 @@ public Observable delay(long delay, TimeUnit unit) {
      * notifications from the source Observable are not delayed.
      * 
    
      * 
-     *
-     * @param delay the delay to shift the source by
-     * @param unit the {@link TimeUnit} in which period is defined
-     * @param scheduler the {@link Scheduler} to use for delaying
+     * 
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            the {@link TimeUnit} in which period is defined
+     * @param scheduler
+     *            the {@link Scheduler} to use for delaying
      * @return the source Observable, but shifted by the specified delay
      * @see RxJava Wiki: delay()
      * @see MSDN: Observable.Delay
@@ -2367,27 +2592,32 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
      * Observable by a given amount of time.
      * 
    
      * 
-     *
-     * @param delay the time to delay the subscription
-     * @param unit the time unit
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit
      * @return an Observable that delays the subscription to the source
      *         Observable by the given amount
      */
     public Observable delaySubscription(long delay, TimeUnit unit) {
         return delaySubscription(delay, unit, Schedulers.threadPoolForComputation());
     }
-    
+
     /**
      * Return an Observable that delays the subscription to the source
      * Observable by a given amount of time, both waiting and subscribing on
      * a given Scheduler.
      * 
    
      * 
-     *
-     * @param delay the time to delay the subscription
-     * @param unit the time unit
-     * @param scheduler the scheduler on which the waiting and subscription will
-     *                  happen
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler on which the waiting and subscription will
+     *            happen
      * @return an Observable that delays the subscription to the source
      *         Observable by a given amount, waiting and subscribing on the
      *         given Scheduler
@@ -2395,7 +2625,7 @@ public Observable delaySubscription(long delay, TimeUnit unit) {
     public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(OperationDelay.delaySubscription(this, delay, unit, scheduler));
     }
-    
+
     /**
      * Drops items emitted by an Observable that are followed by newer items
      * before a timeout value expires. The timer resets on each emission.
@@ -2413,10 +2643,12 @@ public Observable delaySubscription(long delay, TimeUnit unit, Scheduler sche
      * 
  • Javascript - don't spam your server: debounce and throttle
    • 
      * 
      * 
-     * @param timeout the time each item has to be "the most recent" of those
-     *                emitted by the source {@link Observable} to ensure that
-     *                it's not dropped
-     * @param unit the {@link TimeUnit} for the timeout 
+     * @param timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
+     * @param unit
+     *            the {@link TimeUnit} for the timeout
      * @return an {@link Observable} that filters out items that are too quickly
      *         followed by newer items
      * @see RxJava Wiki: debounce()
@@ -2430,16 +2662,19 @@ public Observable debounce(long timeout, TimeUnit unit) {
      * Create an Observable that ignores elements from this observable
      * sequence which are followed by another value within a computed
      * debounce duration.
-     * @param  the debounce value type (ignored)
-     * @param debounceSelector function to retrieve a sequence indicating the throttle duration for each given element.
+     * 
+     * @param 
+     *            the debounce value type (ignored)
+     * @param debounceSelector
+     *            function to retrieve a sequence indicating the throttle duration for each given element.
      * @return an Observable that ignores elements from this observable
-     * sequence which are followed by another value within a computed
-     * debounce duration
+     *         sequence which are followed by another value within a computed
+     *         debounce duration
      */
     public  Observable debounce(Func1> debounceSelector) {
         return create(OperationDebounce.debounceSelector(this, debounceSelector));
     }
-    
+
     /**
      * Drops items emitted by an Observable that are followed by newer items
      * before a timeout value expires. The timer resets on each emission.
@@ -2457,12 +2692,15 @@ public  Observable debounce(Func1> debo
      * 
  • Javascript - don't spam your server: debounce and throttle
    • 
      * 
      * 
-     * @param timeout the time each item has to be "the most recent" of those
-     *                emitted by the source {@link Observable} to ensure that
-     *                it's not dropped
-     * @param unit the unit of time for the specified timeout
-     * @param scheduler the {@link Scheduler} to use internally to manage the
-     *                  timers that handle the timeout for each event
+     * @param timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
+     * @param unit
+     *            the unit of time for the specified timeout
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle the timeout for each event
      * @return an {@link Observable} that filters out items that are too quickly
      *         followed by newer items
      * @see RxJava Wiki: debounce()
@@ -2489,10 +2727,12 @@ public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler)
      * 
  • Javascript - don't spam your server: debounce and throttle
    • 
      * 
      * 
-     * @param timeout the time each item has to be "the most recent" of those
-     *                emitted by the source {@link Observable} to ensure that
-     *                it's not dropped
-     * @param unit the {@link TimeUnit} for the timeout
+     * @param timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
+     * @param unit
+     *            the {@link TimeUnit} for the timeout
      * @return an {@link Observable} that filters out items that are too quickly
      *         followed by newer items
      * @see RxJava Wiki: throttleWithTimeout()
@@ -2519,11 +2759,14 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit) {
      * 
  • Javascript - don't spam your server: debounce and throttle
    • 
      * 
      * 
-     * @param timeout the time each item has to be "the most recent" emitted by
-     *                the {@link Observable} to ensure that it's not dropped
-     * @param unit the {@link TimeUnit} for the timeout
-     * @param scheduler the {@link Scheduler} to use internally to manage the
-     *                  timers that handle the timeout for each item
+     * @param timeout
+     *            the time each item has to be "the most recent" emitted by
+     *            the {@link Observable} to ensure that it's not dropped
+     * @param unit
+     *            the {@link TimeUnit} for the timeout
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle the timeout for each item
      * @return an {@link Observable} that filters out items that are too quickly
      *         followed by newer items
      * @see RxJava Wiki: throttleWithTimeout()
@@ -2543,9 +2786,11 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler
      * 
    
      * 
      * 
-     * @param windowDuration time to wait before emitting another item after
-     *                       emitting the last item
-     * @param unit the unit of time for the specified timeout
+     * @param windowDuration
+     *            time to wait before emitting another item after
+     *            emitting the last item
+     * @param unit
+     *            the unit of time for the specified timeout
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleFirst()
      */
@@ -2563,11 +2808,14 @@ public Observable throttleFirst(long windowDuration, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param skipDuration time to wait before emitting another item after
-     *                     emitting the last item
-     * @param unit the unit of time for the specified timeout
-     * @param scheduler the {@link Scheduler} to use internally to manage the
-     *                  timers that handle timeout for each event
+     * @param skipDuration
+     *            time to wait before emitting another item after
+     *            emitting the last item
+     * @param unit
+     *            the unit of time for the specified timeout
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle timeout for each event
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleFirst()
      */
@@ -2585,9 +2833,11 @@ public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler s
      * 
    
      * 
      * 
-     * @param intervalDuration duration of windows within which the last item
-     *                         emitted by the source Observable will be emitted
-     * @param unit the unit of time for the specified interval
+     * @param intervalDuration
+     *            duration of windows within which the last item
+     *            emitted by the source Observable will be emitted
+     * @param unit
+     *            the unit of time for the specified interval
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleLast()
      * @see #sample(long, TimeUnit)
@@ -2606,11 +2856,14 @@ public Observable throttleLast(long intervalDuration, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param intervalDuration duration of windows within which the last item
-     *                         emitted by the source Observable will be emitted
-     * @param unit the unit of time for the specified interval
-     * @param scheduler the {@link Scheduler} to use internally to manage the
-     *                  timers that handle timeout for each event
+     * @param intervalDuration
+     *            duration of windows within which the last item
+     *            emitted by the source Observable will be emitted
+     * @param unit
+     *            the unit of time for the specified interval
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle timeout for each event
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleLast()
      * @see #sample(long, TimeUnit, Scheduler)
@@ -2620,8 +2873,7 @@ public Observable throttleLast(long intervalDuration, TimeUnit unit, Schedule
     }
 
     /**
-     * Wraps each item emitted by a source Observable in a {@link Timestamped}
-     * object.
+     * Wraps each item emitted by a source Observable in a {@link Timestamped} object.
      * 
    
      * 
      * 
@@ -2635,12 +2887,12 @@ public Observable> timestamp() {
     }
 
     /**
-     * Wraps each item emitted by a source Observable in a {@link Timestamped}
-     * object with timestamps provided by the given Scheduler.
+     * Wraps each item emitted by a source Observable in a {@link Timestamped} object with timestamps provided by the given Scheduler.
      * 
    
      * 
      * 
-     * @param scheduler the {@link Scheduler} to use as a time source.
+     * @param scheduler
+     *            the {@link Scheduler} to use as a time source.
      * @return an Observable that emits timestamped items from the source
      *         Observable with timestamps provided by the given Scheduler
      * @see RxJava Wiki: timestamp()
@@ -2656,15 +2908,15 @@ public Observable> timestamp(Scheduler scheduler) {
      * 
      * 
    
      * 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.
+     * 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
+     * @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
      * @see RxJava Wiki: from()
@@ -2679,16 +2931,16 @@ public static  Observable from(Future future) {
      * 
      * 
    
      * 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.
+     * 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
+     * @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
      * @see RxJava Wiki: from()
@@ -2704,16 +2956,19 @@ public static  Observable from(Future future, Scheduler sched
      * 
    
      * 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.
+     * 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 timeout argument
-     * @param  the type of object that the {@link Future} returns, and also
+     * @param future
+     *            the source {@link Future}
+     * @param timeout
+     *            the maximum time to wait before calling get()
+     * @param unit
+     *            the {@link TimeUnit} of the timeout 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}
      * @see RxJava Wiki: from()
@@ -2729,9 +2984,12 @@ public static  Observable from(Future future, long timeout, T
      * 
    
      * 
      * 
-     * @param first the first Observable to compare
-     * @param second the second Observable to compare
-     * @param  the type of items emitted by each Observable
+     * @param first
+     *            the first Observable to compare
+     * @param second
+     *            the second Observable to compare
+     * @param 
+     *            the type of items emitted by each Observable
      * @return an Observable that emits a Boolean value that indicates whether
      *         two sequences are equal by comparing the elements pairwise
      * @see RxJava Wiki: sequenceEqual()
@@ -2740,7 +2998,7 @@ public static  Observable sequenceEqual(Observable firs
         return sequenceEqual(first, second, new Func2() {
             @Override
             public Boolean call(T first, T second) {
-                if(first == null) {
+                if (first == null) {
                     return second == null;
                 }
                 return first.equals(second);
@@ -2756,11 +3014,15 @@ public Boolean call(T first, T second) {
      * 
    
      * 
      * 
-     * @param first the first 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
+     * @param first
+     *            the first 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 a Boolean value that indicates whether
      *         two sequences are equal by comparing the elements pairwise
      * @see RxJava Wiki: sequenceEqual()
@@ -2775,22 +3037,21 @@ public static  Observable sequenceEqual(Observable firs
      * two other Observables.
      * 
    
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 o1} and the first item emitted by
-     * {@code o2}; the second item emitted by the new Observable will be the
-     * result of the function applied to the second item emitted by {@code o1}
-     * and the second item emitted by {@code o2}; and so forth.
+     * to the first item emitted by {@code o1} and the first item emitted by {@code o2}; the second item emitted by the new Observable will be the
+     * result of the function applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; 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
+     * 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 the first source Observable
-     * @param o2 another source Observable
-     * @param zipFunction a function that, when applied to an item emitted by
+     * @param o1
+     *            the first 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
@@ -2803,13 +3064,18 @@ public static  Observable zip(Observable o1, Observa
     /**
      * Return an Observable that pairs up values from this Observable and the other
      * Observable and applies a function.
-     * @param  the other value type
-     * @param  the result type
-     * @param other the other Observable sequence
-     * @param zipFunction the function that combines the pairs of items from both
-     * observables and returns a new value
+     * 
+     * @param 
+     *            the other value type
+     * @param 
+     *            the result type
+     * @param other
+     *            the other Observable sequence
+     * @param zipFunction
+     *            the function that combines the pairs of items from both
+     *            observables and returns a new value
      * @return an Observable that pairs up values from this Observable and the other
-     * Observable and applies a function.
+     *         Observable and applies a function.
      */
     public  Observable zip(Observable other, Func2 zipFunction) {
         return zip(this, other, zipFunction);
@@ -2822,13 +3088,18 @@ public  Observable zip(Observable other, Func2 the other value type
-     * @param  the result type
-     * @param other the other Iterable sequence
-     * @param zipFunction the function that combines the pairs of items of
-     * this Observable and the Iterable
+     * 
+     * @param 
+     *            the other value type
+     * @param 
+     *            the result type
+     * @param other
+     *            the other Iterable sequence
+     * @param zipFunction
+     *            the function that combines the pairs of items of
+     *            this Observable and the Iterable
      * @return an Observable that pairs up values from this Observable and an
-     * Iterable sequence and applies a function.
+     *         Iterable sequence and applies a function.
      */
     public  Observable zip(Iterable other, Func2 zipFunction) {
         return create(OperationZip.zipIterable(this, other, zipFunction));
@@ -2840,26 +3111,26 @@ public  Observable zip(Iterable other, Func2
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 o1}, the first item emitted by
-     * {@code o2}, and the first item emitted by {@code o3}; the second item
+     * to the first item emitted by {@code o1}, the first item emitted by {@code o2}, and the first item emitted by {@code o3}; the second item
      * emitted by the new Observable will be the result of the function applied
-     * to the second item emitted by {@code o1}, the second item emitted by
-     * {@code o2}, and the second item emitted by {@code o3}; and so forth.
+     * to the second item emitted by {@code o1}, the second item emitted by {@code o2}, and the second item emitted by {@code o3}; 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -2873,25 +3144,27 @@ public static  Observable zip(Observable o1, Obs
      * four other Observables.
      * 
    
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 o1}, the first item emitted by
-     * {@code o2}, the first item emitted by {@code o3}, and the first item
+     * to the first item emitted by {@code o1}, the first item emitted by {@code o2}, the first item emitted by {@code o3}, and the first item
      * emitted by {@code 04}; 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
+     * 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
+     * @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
@@ -2907,28 +3180,31 @@ public static  Observable zip(Observable o1,
      * five other Observables.
      * 
    
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 o1}, the first item emitted by
-     * {@code o2}, the first item emitted by {@code o3}, the first item emitted
+     * to the first item emitted by {@code o1}, the first item emitted by {@code o2}, the first item emitted by {@code o3}, the first item emitted
      * by {@code o4}, and the first item emitted by {@code o5}; 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -2942,27 +3218,32 @@ public static  Observable zip(Observable
      * six other Observables.
      * 
    
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 each source Observable, 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -2977,28 +3258,34 @@ public static  Observable zip(Observable
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 each source Observable, 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -3013,29 +3300,36 @@ public static  Observable zip(Observable
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 each source Observable, 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -3050,30 +3344,38 @@ public static  Observable zip(Observable
      * 
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 each source Observable, 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
+     * 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 the first 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
+     * @param o1
+     *            the first 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
      * @see RxJava Wiki: zip()
      */
@@ -3090,10 +3392,13 @@ public static  Observable zip(Observab
      * 
    
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3111,11 +3416,15 @@ public static  Observable combineLatest(Observable o
      * 
    
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3133,12 +3442,17 @@ public static  Observable combineLatest(Observable
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3157,13 +3471,19 @@ public static  Observable combineLatest(Observable
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param o5 the fifth source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3182,14 +3502,21 @@ public static  Observable combineLatest(Observable
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param o5 the fifth source Observable
-     * @param o6 the sixth source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3208,15 +3535,23 @@ public static  Observable combineLatest(Observable
      * 
    
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param o5 the fifth source Observable
-     * @param o6 the sixth source Observable
-     * @param o7 the seventh source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3235,16 +3570,25 @@ public static  Observable combineLatest(Observ
      * 
    
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param o5 the fifth source Observable
-     * @param o6 the sixth source Observable
-     * @param o7 the seventh source Observable
-     * @param o8 the eighth source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param o8
+     *            the eighth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3263,17 +3607,27 @@ public static  Observable combineLatest(Ob
      * 
    
      * 
      * 
-     * @param o1 the first source Observable
-     * @param o2 the second source Observable
-     * @param o3 the third source Observable
-     * @param o4 the fourth source Observable
-     * @param o5 the fifth source Observable
-     * @param o6 the sixth source Observable
-     * @param o7 the seventh source Observable
-     * @param o8 the eighth source Observable
-     * @param o9 the ninth source Observable
-     * @param combineFunction the aggregation function used to combine the
-     *                        items emitted by the source Observables
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param o8
+     *            the eighth source Observable
+     * @param o9
+     *            the ninth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
      * @return an Observable whose emissions are the result of combining the
      *         emissions of the source Observables with the given aggregation
      *         function
@@ -3289,30 +3643,37 @@ public static  Observable combineLates
      * 
    
      * Completion of either this or the boundary observable causes the returned observable
      * to emit the latest buffer and complete.
-     * @param  the boundary value type (ignored)
-     * @param boundary the boundary observable
+     * 
+     * @param 
+     *            the boundary value type (ignored)
+     * @param boundary
+     *            the boundary observable
      * @return an Observable that emits buffered items once the boundary observable emits an item.
-     * @see #buffer(rx.Observable, int) 
+     * @see #buffer(rx.Observable, int)
      */
     public  Observable> buffer(Observable boundary) {
         return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
     }
-    
+
     /**
      * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
      * 
    
      * Completion of either this or the boundary observable causes the returned observable
      * to emit the latest buffer and complete.
-     * @param  the boundary value type (ignored)
-     * @param boundary the boundary observable
-     * @param initialCapacity the initial capacity of each buffer chunk
+     * 
+     * @param 
+     *            the boundary value type (ignored)
+     * @param boundary
+     *            the boundary observable
+     * @param initialCapacity
+     *            the initial capacity of each buffer chunk
      * @return an Observable that emits buffered items once the boundary observable emits an item.
-     * @see #buffer(rx.Observable, int) 
+     * @see #buffer(rx.Observable, int)
      */
     public  Observable> buffer(Observable boundary, int initialCapacity) {
         return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
     }
-    
+
     /**
      * Creates an Observable that emits buffers of items it collects from the
      * source Observable. The resulting Observable emits connected,
@@ -3324,15 +3685,15 @@ public  Observable> buffer(Observable boundary, int initialCapacit
      * 
    
      * 
      * 
-     * @param bufferClosingSelector the {@link Func0} which is used to produce
-     *                              an {@link Observable} for every buffer
-     *                              created. When this {@link Observable} emits
-     *                              an item, buffer() emits the
-     *                              associated buffer and replaces it with a new
-     *                              one.
+     * @param bufferClosingSelector
+     *            the {@link Func0} which is used to produce
+     *            an {@link Observable} for every buffer
+     *            created. When this {@link Observable} emits
+     *            an item, buffer() emits the
+     *            associated buffer and replaces it with a new
+     *            one.
      * @return an {@link Observable} that emits connected, non-overlapping
-     *         buffers when the current {@link Observable} created with the
-     *         {@code bufferClosingSelector} argument emits an item
+     *         buffers when the current {@link Observable} created with the {@code bufferClosingSelector} argument emits an item
      * @see RxJava Wiki: buffer()
      */
     public  Observable> buffer(Func0> bufferClosingSelector) {
@@ -3348,12 +3709,14 @@ public  Observable> buffer(Func0
      * 
      * 
-     * @param bufferOpenings the {@link Observable} that, when it emits an item,
-     *                       causes a new buffer to be created
-     * @param bufferClosingSelector the {@link Func1} that is used to produce
-     *                              an {@link Observable} for every buffer
-     *                              created. When this {@link Observable} emits
-     *                              an item, the associated buffer is emitted.
+     * @param bufferOpenings
+     *            the {@link Observable} that, when it emits an item,
+     *            causes a new buffer to be created
+     * @param bufferClosingSelector
+     *            the {@link Func1} that is used to produce
+     *            an {@link Observable} for every buffer
+     *            created. When this {@link Observable} emits
+     *            an item, the associated buffer is emitted.
      * @return an {@link Observable} that emits buffers that are created and
      *         closed when the specified {@link Observable}s emit items
      * @see RxJava Wiki: buffer()
@@ -3372,8 +3735,9 @@ public  Observable> buffer(Observable
      * 
      * 
-     * @param count the maximum number of items in each buffer before it should
-     *              be emitted
+     * @param count
+     *            the maximum number of items in each buffer before it should
+     *            be emitted
      * @return an {@link Observable} that emits connected, non-overlapping
      *         buffers, each containing at most "count" items from the source
      *         Observable
@@ -3393,11 +3757,12 @@ public Observable> buffer(int count) {
      * 
    
      * 
      * 
-     * @param count the maximum size of each buffer before it should be emitted
-     * @param skip how many produced items need to be skipped before starting a
-     *             new buffer. Note that when skip and
-     *             count are equal, this is the same operation as
-     *             {@link Observable#buffer(int)}.
+     * @param count
+     *            the maximum size of each buffer before it should be emitted
+     * @param skip
+     *            how many produced items need to be skipped before starting a
+     *            new buffer. Note that when skip and
+     *            count are equal, this is the same operation as {@link Observable#buffer(int)}.
      * @return an {@link Observable} that emits buffers every skip
      *         item and containing at most count items
      * @see RxJava Wiki: buffer()
@@ -3416,10 +3781,12 @@ public Observable> buffer(int count, int skip) {
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items before it
-     *                 should be emitted and replaced with a new buffer
-     * @param unit the unit of time which applies to the timespan
-     *             argument
+     * @param timespan
+     *            the period of time each buffer collects items 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} that emits connected, non-overlapping
      *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
@@ -3438,12 +3805,15 @@ public Observable> buffer(long timespan, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items 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
+     * @param timespan
+     *            the period of time each buffer collects items 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} that emits connected, non-overlapping
      *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
@@ -3464,11 +3834,14 @@ public Observable> buffer(long timespan, TimeUnit unit, Scheduler schedu
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items 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 timespan
+     *            the period of time each buffer collects items 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} that emits connected, non-overlapping
      *         buffers of items emitted from the source Observable, after a
      *         fixed duration or when the buffer reaches maximum capacity
@@ -3491,13 +3864,17 @@ public Observable> buffer(long timespan, TimeUnit unit, int count) {
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items 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
+     * @param timespan
+     *            the period of time each buffer collects items 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} that emits connected, non-overlapping
      *         buffers of items emitted by the source Observable after a fixed
      *         duration or when the buffer reaches maximum capacity (whichever
@@ -3519,12 +3896,15 @@ public Observable> buffer(long timespan, TimeUnit unit, int count, Sched
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items 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 that applies to the timespan
-     *             and timeshift arguments
+     * @param timespan
+     *            the period of time each buffer collects items 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 that applies to the timespan
+     *            and timeshift arguments
      * @return an {@link Observable} that emits new buffers of items emitted by
      *         the source Observable periodically after a fixed timespan has
      *         elapsed
@@ -3545,14 +3925,18 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit)
      * 
    
      * 
      * 
-     * @param timespan the period of time each buffer collects items 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 that applies to the timespan
-     *             and timeshift arguments
-     * @param scheduler the {@link Scheduler} to use when determining the end
-     *                  and start of a buffer
+     * @param timespan
+     *            the period of time each buffer collects items 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 that applies to the timespan
+     *            and timeshift arguments
+     * @param scheduler
+     *            the {@link Scheduler} to use when determining the end
+     *            and start of a buffer
      * @return an {@link Observable} that emits new buffers of items emitted by
      *         the source Observable periodically after a fixed timespan has
      *         elapsed
@@ -3573,9 +3957,8 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit,
      * 
    
      * 
      * 
-     * @param closingSelector the {@link Func0} used to produce an
-     *            {@link Observable} for every window created. When this
-     *            {@link Observable} emits an item, window() emits
+     * @param closingSelector
+     *            the {@link Func0} used to produce an {@link Observable} for every window created. When this {@link Observable} emits an item, window() emits
      *            the associated window and begins a new one.
      * @return an {@link Observable} that emits connected, non-overlapping
      *         windows when the current {@link Observable} created with the
@@ -3595,36 +3978,39 @@ public  Observable> window(Func0
      * 
      * 
-     * @param windowOpenings the {@link Observable} that, when it emits an item,
-     *                       causes another window to be created
-     * @param closingSelector a {@link Func1} that produces an 
-     *                        {@link Observable} for every window created. When
-     *                        this {@link Observable} emits an item, the
-     *                        associated window is closed and emitted
+     * @param windowOpenings
+     *            the {@link Observable} that, when it emits an item,
+     *            causes another window to be created
+     * @param closingSelector
+     *            a {@link Func1} that produces an {@link Observable} for every window created. When
+     *            this {@link Observable} emits an item, the
+     *            associated window is closed and emitted
      * @return an {@link Observable} that emits windows of items emitted by the
-     *         source Observable that are governed by the specified
-     *         {@link Observable}s emitting items
+     *         source Observable that are governed by the specified {@link Observable}s emitting items
      * @see RxJava Wiki: window()
      */
     public  Observable> window(Observable windowOpenings, Func1> closingSelector) {
         return create(OperationWindow.window(this, windowOpenings, closingSelector));
     }
-    
+
     /**
      * Create an Observable which emits non-overlapping windows of items it collects from the
      * source observable where the boundary of each window is determined by the items
      * emitted from the boundary observable.
-     * @param  the window element type (ignored)
-     * @param boundary the Observable sequence whose emitted item is used for closing
-     *                 and opening windows
+     * 
+     * @param 
+     *            the window element type (ignored)
+     * @param boundary
+     *            the Observable sequence whose emitted item is used for closing
+     *            and opening windows
      * @return an Observable which emits non-overlapping windows of items it collects from the
-     * source observable where the boundary of each window is determined by the items
-     * emitted from the boundary observable
+     *         source observable where the boundary of each window is determined by the items
+     *         emitted from the boundary observable
      */
     public  Observable> window(Observable boundary) {
         return create(OperationWindow.window(this, boundary));
     }
-    
+
     /**
      * Creates an Observable that emits windows of items it collects from the
      * source Observable. The resulting Observable emits connected,
@@ -3635,7 +4021,8 @@ public  Observable> window(Observable boundary) {
      * 
    
      * 
      * 
-     * @param count the maximum size of each window before it should be emitted
+     * @param count
+     *            the maximum size of each window before it should be emitted
      * @return an {@link Observable} that emits connected, non-overlapping
      *         windows containing at most count items
      * @see RxJava Wiki: window()
@@ -3654,10 +4041,12 @@ public Observable> window(int count) {
      * 
    
      * 
      * 
-     * @param count the maximum size of each window before it should be emitted
-     * @param skip how many items need to be skipped before starting a new
-     *             window. Note that if skip and count
-     *             are equal this is the same operation as {@link #window(int)}.
+     * @param count
+     *            the maximum size of each window before it should be emitted
+     * @param skip
+     *            how many items need to be skipped before starting a new
+     *            window. Note that if skip and count
+     *            are equal this is the same operation as {@link #window(int)}.
      * @return an {@link Observable} that emits windows every "skipped"
      *         items containing at most count items
      * @see RxJava Wiki: window()
@@ -3676,10 +4065,12 @@ public Observable> window(int count, int skip) {
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items before it
-     *                 should be emitted and replaced with a new window
-     * @param unit the unit of time that applies to the timespan
-     *             argument
+     * @param timespan
+     *            the period of time each window collects items before it
+     *            should be emitted and replaced with a new window
+     * @param unit
+     *            the unit of time that applies to the timespan
+     *            argument
      * @return an {@link Observable} that emits connected, non-overlapping
      *         windows with a fixed duration
      * @see RxJava Wiki: window()
@@ -3698,12 +4089,15 @@ public Observable> window(long timespan, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items 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
+     * @param timespan
+     *            the period of time each window collects items 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} that emits connected, non-overlapping
      *         windows with a fixed duration
      * @see RxJava Wiki: window()
@@ -3724,11 +4118,14 @@ public Observable> window(long timespan, TimeUnit unit, Scheduler
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items before it
-     *                 should be emitted and replaced with a new window
-     * @param unit the unit of time that applies to the timespan
-     *             argument
-     * @param count the maximum size of each window before it should be emitted
+     * @param timespan
+     *            the period of time each window collects items before it
+     *            should be emitted and replaced with a new window
+     * @param unit
+     *            the unit of time that applies to the timespan
+     *            argument
+     * @param count
+     *            the maximum size of each window before it should be emitted
      * @return an {@link Observable} that emits connected, non-overlapping
      *         windows after a fixed duration or when the window has reached
      *         maximum capacity (whichever occurs first)
@@ -3750,13 +4147,17 @@ public Observable> window(long timespan, TimeUnit unit, int count)
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items 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.
+     * @param timespan
+     *            the period of time each window collects items 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} that emits connected non-overlapping
      *         windows after a fixed duration or when the window has reached
      *         maximum capacity (whichever occurs first).
@@ -3778,12 +4179,15 @@ public Observable> window(long timespan, TimeUnit unit, int count,
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items 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 that applies to the timespan
-     *             and timeshift arguments
+     * @param timespan
+     *            the period of time each window collects items 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 that applies to the timespan
+     *            and timeshift arguments
      * @return an {@link Observable} that emits new windows periodically as a
      *         fixed timespan has elapsed
      * @see RxJava Wiki: window()
@@ -3804,14 +4208,18 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      * 
    
      * 
      * 
-     * @param timespan the period of time each window collects items 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 that applies to the timespan
-     *             and timeshift arguments
-     * @param scheduler the {@link Scheduler} to use when determining the end
-     *                  and start of a window
+     * @param timespan
+     *            the period of time each window collects items 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 that applies to the timespan
+     *            and timeshift arguments
+     * @param scheduler
+     *            the {@link Scheduler} to use when determining the end
+     *            and start of a window
      * @return an {@link Observable} that emits new windows periodically as a
      *         fixed timespan has elapsed
      * @see RxJava Wiki: window()
@@ -3824,8 +4232,7 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      * 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
+     * 
     {@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 source Observables; the second
      * item emitted by the new Observable will be the result of the function
@@ -3833,15 +4240,16 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      * 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.
+     * 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
+     * @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
      * @see RxJava Wiki: zip()
      */
@@ -3858,24 +4266,24 @@ public Observable call(List> wsList) {
      * Returns an Observable that emits the results of a function of your
      * choosing applied to combinations items emitted, in sequence, by a
      * collection of other Observables.
-     * 
    
-     * {@code zip} applies this function in strict sequence, so the first item
+     * 
     {@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 source Observables; 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
+     * 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
+     * @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
      * @see RxJava Wiki: zip()
      */
@@ -3888,9 +4296,10 @@ public static  Observable zip(Iterable> ws, FuncN<
      * 
    
      * 
      * 
-     * @param predicate a function that evaluates the items emitted by the
-     *                  source Observable, returning {@code true} if they pass
-     *                  the filter
+     * @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 emitted by the source
      *         Observable that the filter evaluates as {@code true}
      * @see RxJava Wiki: filter()
@@ -3921,9 +4330,10 @@ public Observable distinctUntilChanged() {
      * 
    
      * 
      * 
-     * @param keySelector a function that projects an emitted item to a key
-     *                    value that is used to decide whether an item is
-     *                    sequentially distinct from another one or not
+     * @param keySelector
+     *            a function that projects an emitted item to a key
+     *            value that is used to decide whether an item is
+     *            sequentially distinct from another one or not
      * @return an Observable that emits those items from the source Observable
      *         whose keys are sequentially distinct
      * @see RxJava Wiki: distinctUntilChanged()
@@ -3954,9 +4364,10 @@ public Observable distinct() {
      * 
    
      * 
      * 
-     * @param keySelector a function that projects an emitted item to a key
-     *                    value that is used to decide whether an item is
-     *                    distinct from another one or not
+     * @param keySelector
+     *            a function that projects an emitted item to a key
+     *            value that is used to decide whether an item is
+     *            distinct from another one or not
      * @return an Observable that emits those items emitted by the source
      *         Observable that have distinct keys
      * @see RxJava Wiki: distinct()
@@ -3972,13 +4383,16 @@ public  Observable distinct(Func1 keySelector) {
      * 
    
      * 
      * 
-     * @param index the zero-based index of the item to retrieve
+     * @param index
+     *            the zero-based index of the item to retrieve
      * @return an Observable that emits the item at the specified position in
      *         the sequence of those emitted by the source Observable
-     * @throws IndexOutOfBoundsException if index is greater than
-     *                                   or equal to the number of items emitted
-     *                                   by the source Observable
-     * @throws IndexOutOfBoundsException if index is less than 0
+     * @throws IndexOutOfBoundsException
+     *             if index is greater than
+     *             or equal to the number of items emitted
+     *             by the source Observable
+     * @throws IndexOutOfBoundsException
+     *             if index is less than 0
      * @see RxJava Wiki: elementAt()
      */
     public Observable elementAt(int index) {
@@ -3991,12 +4405,15 @@ public Observable elementAt(int index) {
      * 
    
      * 
      * 
-     * @param index the zero-based index of the item to retrieve
-     * @param defaultValue the default item
+     * @param index
+     *            the zero-based index of the item to retrieve
+     * @param defaultValue
+     *            the default item
      * @return an Observable that emits the item at the specified position in
      *         the source sequence, or the default item if the index is outside
      *         the bounds of the source sequence
-     * @throws IndexOutOfBoundsException if index is less than 0
+     * @throws IndexOutOfBoundsException
+     *             if index is less than 0
      * @see RxJava Wiki: elementAtOrDefault()
      */
     public Observable elementAtOrDefault(int index, T defaultValue) {
@@ -4014,8 +4431,9 @@ public Observable elementAtOrDefault(int index, T defaultValue) {
      * 
    
      * 
      * 
-     * @param predicate the condition to test every item emitted by the source
-     *                  Observable
+     * @param predicate
+     *            the condition to test every item emitted by the source
+     *            Observable
      * @return a subscription function for creating the target Observable
      * @see RxJava Wiki: exists()
      * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
@@ -4030,8 +4448,9 @@ public Observable exists(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param element the item to search for in the emissions from the source
-     *                Observable
+     * @param element
+     *            the item to search for in the emissions from the source
+     *            Observable
      * @return an Observable that emits true if the specified item
      *         is emitted by the source Observable, or false if the
      *         source Observable completes without emitting that item
@@ -4047,14 +4466,13 @@ public Boolean call(T t1) {
     }
 
     /**
-     * Registers an {@link Action0} to be called when this Observable invokes
-     * {@link Observer#onCompleted onCompleted} or
-     * {@link Observer#onError onError}.
+     * 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
+     * @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 RxJava Wiki: finallyDo()
@@ -4074,8 +4492,9 @@ public Observable finallyDo(Action0 action) {
      * 
    
      * 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
+     * @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
@@ -4086,7 +4505,7 @@ public Observable finallyDo(Action0 action) {
     public  Observable flatMap(Func1> func) {
         return mergeMap(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
@@ -4095,8 +4514,9 @@ public  Observable flatMap(Func1
      * 
      * 
-     * @param func a function that, when applied to an item emitted by the
-     *             source Observable, returns an Observable
+     * @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
@@ -4107,68 +4527,86 @@ public  Observable flatMap(Func1 Observable mergeMap(Func1> func) {
         return merge(map(func));
     }
-    
+
     /**
      * Create an Observable that applies a function to the pair of values from the source
      * Observable and the collection Observable.
-     * @param  the element type of the collection Observable
-     * @param  the result type
-     * @param collectionSelector function that returns an Observable sequence for each value in the source Observable
-     * @param resultSelector function that combines the values of the source and collection Observable
+     * 
+     * @param 
+     *            the element type of the collection Observable
+     * @param 
+     *            the result type
+     * @param collectionSelector
+     *            function that returns an Observable sequence for each value in the source Observable
+     * @param resultSelector
+     *            function that combines the values of the source and collection Observable
      * @return an Observable that applies a function to the pair of values from the source
-     * Observable and the collection Observable.
+     *         Observable and the collection Observable.
      */
     public  Observable mergeMap(Func1> collectionSelector,
             Func2 resultSelector) {
         return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
     }
-    
+
     /**
      * Create an Observable that merges the values of the iterables returned by the
      * collectionSelector for each source value.
-     * @param  the result value type
-     * @param collectionSelector function that returns an Iterable sequence of values for
-     * each source value.
+     * 
+     * @param 
+     *            the result value type
+     * @param collectionSelector
+     *            function that returns an Iterable sequence of values for
+     *            each source value.
      * @return an Observable that merges the values of the iterables returned by the
-     * collectionSelector for each source value.
+     *         collectionSelector for each source value.
      */
     public  Observable mergeMapIterable(Func1> collectionSelector) {
         return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
     }
-    
+
     /**
      * Create an Observable that applies a function to the pair of values from the source
      * Observable and the collection Iterable sequence.
-     * @param  the collection element type
-     * @param  the result type
-     * @param collectionSelector function that returns an Iterable sequence of values for
-     * each source value.
-     * @param resultSelector function that combines the values of the source and collection Iterable
+     * 
+     * @param 
+     *            the collection element type
+     * @param 
+     *            the result type
+     * @param collectionSelector
+     *            function that returns an Iterable sequence of values for
+     *            each source value.
+     * @param resultSelector
+     *            function that combines the values of the source and collection Iterable
      * @return n Observable that applies a function to the pair of values from the source
-     * Observable and the collection Iterable sequence.
+     *         Observable and the collection Iterable sequence.
      */
     public  Observable mergeMapIterable(Func1> collectionSelector,
             Func2 resultSelector) {
         return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
     }
-    
+
     /**
      * Create an Observable that projects the notification of an observable sequence to an observable
      * sequence and merges the results into one.
-     * @param  the result type
-     * @param onNext function returning a collection to merge for each onNext event of the source
-     * @param onError function returning a collection to merge for an onError event
-     * @param onCompleted function returning a collection to merge for an onCompleted event
+     * 
+     * @param 
+     *            the result type
+     * @param onNext
+     *            function returning a collection to merge for each onNext event of the source
+     * @param onError
+     *            function returning a collection to merge for an onError event
+     * @param onCompleted
+     *            function returning a collection to merge for an onCompleted event
      * @return an Observable that projects the notification of an observable sequence to an observable
-     * sequence and merges the results into one.
+     *         sequence and merges the results into one.
      */
     public  Observable mergeMap(
-            Func1> onNext, 
-            Func1> onError, 
+            Func1> onNext,
+            Func1> onError,
             Func0> onCompleted) {
         return create(OperationFlatMap.flatMap(this, onNext, onError, onCompleted));
     }
-    
+
     /**
      * Creates a new Observable by applying a function that you supply to each
      * item emitted by the source Observable, where that function returns an
@@ -4177,8 +4615,9 @@ public  Observable mergeMap(
      * 
    
      * 
      * 
-     * @param func a function that, when applied to an item emitted by the
-     *             source Observable, returns an Observable
+     * @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 concatting the results of the Observables obtained
@@ -4187,17 +4626,17 @@ public  Observable mergeMap(
     public  Observable concatMap(Func1> func) {
         return concat(map(func));
     }
-    
+
     /**
      * Creates a new Observable by applying a function that you supply to each
      * item emitted by the source Observable resulting in an Observable of
-     * Observables. Then a {@link #switchLatest(Observable)} /
-     * {@link #switchOnNext(Observable)} is applied.
+     * Observables. Then a {@link #switchLatest(Observable)} / {@link #switchOnNext(Observable)} is applied.
      * 
    
      * 
      * 
-     * @param func a function that, when applied to an item emitted by the
-     *             source Observable, returns an Observable
+     * @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 then switch
@@ -4211,9 +4650,10 @@ public  Observable switchMap(Func1
      * 
      * 
-     * @param predicate a function that evaluates an item emitted by the source
-     *                  Observable, returning {@code true} if it passes the
-     *                  filter
+     * @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 emitted by the source
      *         Observable that the filter evaluates as {@code true}
      * @see RxJava Wiki: where()
@@ -4231,7 +4671,8 @@ public Observable where(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param func a function to apply to each item emitted by the Observable
+     * @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
      * @see RxJava Wiki: map()
@@ -4248,9 +4689,10 @@ public  Observable map(Func1 func) {
      * 
    
      * 
      * 
-     * @param func a function to apply to each item emitted by the Observable
-     *             that takes the index of the emitted item as additional
-     *             parameter
+     * @param func
+     *            a function to apply to each item emitted by the Observable
+     *            that takes the index of the emitted item as additional
+     *            parameter
      * @return an Observable that emits the items from the source Observable,
      *         transformed by the given function
      * @see RxJava Wiki: mapWithIndex()
@@ -4272,8 +4714,9 @@ public  Observable mapWithIndex(Func2 fun
      * 
    
      * Note: mapMany and flatMap are equivalent.
      * 
-     * @param func a function that, when applied to an item emitted by the
-     *             source Observable, returns an Observable
+     * @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
@@ -4289,8 +4732,7 @@ public  Observable mapMany(Func1
      * 
      * 
@@ -4304,13 +4746,13 @@ public Observable> materialize() {
     }
 
     /**
-     * Asynchronously subscribes and unsubscribes Observers on the specified
-     * {@link Scheduler}.
+     * Asynchronously subscribes and unsubscribes Observers on the specified {@link Scheduler}.
      * 
    
      * 
      * 
-     * @param scheduler the {@link Scheduler} to perform subscription and
-     *                  unsubscription actions on
+     * @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}
      * @see RxJava Wiki: subscribeOn()
@@ -4320,12 +4762,12 @@ public Observable subscribeOn(Scheduler scheduler) {
     }
 
     /**
-     * Asynchronously notify {@link Observer}s on the specified
-     * {@link Scheduler}.
+     * Asynchronously notify {@link Observer}s on the specified {@link Scheduler}.
      * 
    
      * 
      * 
-     * @param scheduler the {@link Scheduler} to notify {@link Observer}s on
+     * @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}
      * @see RxJava Wiki: observeOn()
@@ -4335,17 +4777,16 @@ public Observable observeOn(Scheduler 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
+     * 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
-     * @throws Throwable if the source Observable is not of type
-     *                   {@code Observable>}
+     * @throws Throwable
+     *             if the source Observable is not of type {@code Observable>}
      * @see RxJava Wiki: dematerialize()
      * @see MSDN: Observable.dematerialize
      */
@@ -4369,17 +4810,17 @@ public  Observable dematerialize() {
      * 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
+     * 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
+     * @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
      * @see RxJava Wiki: onErrorResumeNext()
      */
@@ -4402,17 +4843,17 @@ public Observable onErrorResumeNext(final Func1onErrorResumeNext 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
+     * 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
+     * @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
      * @see RxJava Wiki: onErrorResumeNext()
      */
@@ -4440,17 +4881,17 @@ public Observable onErrorResumeNext(final Observable resumeSeque
      * 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
+     * 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
+     * @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
      * @see RxJava Wiki: onExceptionResumeNextViaObservable()
      */
@@ -4478,9 +4919,10 @@ public Observable onExceptionResumeNext(final Observable resumeS
      * 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
+     * @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
      * @see RxJava Wiki: onErrorReturn()
      */
@@ -4503,12 +4945,14 @@ public Observable onErrorReturn(Func1 resumeFunction)
      * 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
+     * @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
-     * @throws IllegalArgumentException if the source Observable emits no items
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
      * @see RxJava Wiki: reduce()
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
@@ -4549,7 +4993,8 @@ public Integer call(Integer t1, T t2) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the sum of
+     * @param source
+     *            source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Integers emitted by
      *         the source Observable as its single item
      * @see RxJava Wiki: sumInteger()
@@ -4558,7 +5003,7 @@ public Integer call(Integer t1, T t2) {
     public static Observable sumInteger(Observable source) {
         return OperationSum.sum(source);
     }
-    
+
     @Deprecated
     public static Observable sum(Observable source) {
         return OperationSum.sum(source);
@@ -4570,7 +5015,8 @@ public static Observable sum(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the sum of
+     * @param source
+     *            source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Longs emitted by the
      *         source Observable as its single item
      * @see RxJava Wiki: sumLong()
@@ -4586,7 +5032,8 @@ public static Observable sumLong(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the sum of
+     * @param source
+     *            source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Floats emitted by the
      *         source Observable as its single item
      * @see RxJava Wiki: sumFloat()
@@ -4602,7 +5049,8 @@ public static Observable sumFloat(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the sum of
+     * @param source
+     *            source Observable to compute the sum of
      * @return an Observable that emits the sum of all the Doubles emitted by
      *         the source Observable as its single item
      * @see RxJava Wiki: sumDouble()
@@ -4619,8 +5067,9 @@ public static Observable sumDouble(Observable source) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to extract an integer from each item
-     *                       emitted by the source Observable
+     * @param valueExtractor
+     *            the function to extract an integer from each item
+     *            emitted by the source Observable
      * @return an Observable that emits the integer sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
@@ -4638,8 +5087,9 @@ public Observable sumInteger(Func1 valueExtractor)
      * 
    
      * 
      * 
-     * @param valueExtractor the function to extract a long from each item
-     *                       emitted by the source Observable
+     * @param valueExtractor
+     *            the function to extract a long from each item
+     *            emitted by the source Observable
      * @return an Observable that emits the long sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
@@ -4657,8 +5107,9 @@ public Observable sumLong(Func1 valueExtractor) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to extract a float from each item
-     *                       emitted by the source Observable
+     * @param valueExtractor
+     *            the function to extract a float from each item
+     *            emitted by the source Observable
      * @return an Observable that emits the float sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
@@ -4676,8 +5127,9 @@ public Observable sumFloat(Func1 valueExtractor) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to extract a double from each item
-     *                       emitted by the source Observable
+     * @param valueExtractor
+     *            the function to extract a double from each item
+     *            emitted by the source Observable
      * @return an Observable that emits the double sum of the integer values
      *         corresponding to the items emitted by the source Observable
      *         transformed by the provided function
@@ -4687,24 +5139,26 @@ public Observable sumFloat(Func1 valueExtractor) {
     public Observable sumDouble(Func1 valueExtractor) {
         return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
     }
-    
+
     /**
      * Returns an Observable that computes the average of the Integers emitted
      * by the source Observable.
      * 
    
      * 
      * 
-     * @param source source observable to compute the average of
+     * @param source
+     *            source observable to compute the average of
      * @return an Observable that emits the average of all the Integers emitted
      *         by the source Observable as its single item
-     * @throws IllegalArgumentException if the source Observable emits no items
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
      * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
     public static Observable averageInteger(Observable source) {
         return OperationAverage.average(source);
     }
-    
+
     @Deprecated
     public static Observable average(Observable source) {
         return OperationAverage.average(source);
@@ -4716,7 +5170,8 @@ public static Observable average(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the average of
+     * @param source
+     *            source Observable to compute the average of
      * @return an Observable that emits the average of all the Longs emitted by
      *         the source Observable as its single item
      * @see RxJava Wiki: averageLong()
@@ -4732,7 +5187,8 @@ public static Observable averageLong(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the average of
+     * @param source
+     *            source Observable to compute the average of
      * @return an Observable that emits the average of all the Floats emitted by
      *         the source Observable as its single item
      * @see RxJava Wiki: averageFloat()
@@ -4748,7 +5204,8 @@ public static Observable averageFloat(Observable source) {
      * 
    
      * 
      * 
-     * @param source source Observable to compute the average of
+     * @param source
+     *            source Observable to compute the average of
      * @return an Observable that emits the average of all the Doubles emitted
      *         by the source Observable as its single item
      * @see RxJava Wiki: averageDouble()
@@ -4765,8 +5222,9 @@ public static Observable averageDouble(Observable source) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to transform an item emitted by the
-     *                       source Observable into an integer
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into an integer
      * @return an Observable that emits the integer average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into integers by the specified function
@@ -4784,8 +5242,9 @@ public Observable averageInteger(Func1 valueExtract
      * 
    
      * 
      * 
-     * @param valueExtractor the function to transform an item emitted by the
-     *                       source Observable into a long
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a long
      * @return an Observable that emits the long average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into longs by the specified function
@@ -4803,8 +5262,9 @@ public Observable averageLong(Func1 valueExtractor) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to transform an item emitted by the
-     *                       source Observable into a float
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a float
      * @return an Observable that emits the float average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into floats by the specified function
@@ -4822,8 +5282,9 @@ public Observable averageFloat(Func1 valueExtractor) {
      * 
    
      * 
      * 
-     * @param valueExtractor the function to transform an item emitted by the
-     *                       source Observable into a double
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a double
      * @return an Observable that emits the double average of the complete
      *         sequence of items emitted by the source Observable when
      *         transformed into doubles by the specified function
@@ -4840,11 +5301,13 @@ public Observable averageDouble(Func1 valueExtractor)
      * last-emitted one.
      * 
    
      * 
-     *
-     * @param source an Observable to determine the minimum item of
+     * 
+     * @param source
+     *            an Observable to determine the minimum item of
      * @return an Observable that emits the minimum item emitted by the source
      *         Observable
-     * @throws IllegalArgumentException if the source is empty
+     * @throws IllegalArgumentException
+     *             if the source is empty
      * @see MSDN: Observable.Min
      */
     public static > Observable min(Observable source) {
@@ -4857,11 +5320,13 @@ public static > Observable min(Observable
      * one such item, it returns the last-emitted one.
      * 
    
      * 
-     *
-     * @param comparator the comparer used to compare elements
+     * 
+     * @param comparator
+     *            the comparer used to compare elements
      * @return an Observable that emits the minimum item according to the
      *         specified comparator
-     * @throws IllegalArgumentException if the source is empty
+     * @throws IllegalArgumentException
+     *             if the source is empty
      * @see RxJava Wiki: min()
      * @see MSDN: Observable.Min
      */
@@ -4875,8 +5340,9 @@ public Observable min(Comparator comparator) {
      * emits no items, the resulting Observable emits an empty List.
      * 
    
      * 
-     *
-     * @param selector the key selector function
+     * 
+     * @param selector
+     *            the key selector function
      * @return an Observable that emits a List of the items from the source
      *         Observable that had the minimum key value
      * @see RxJava Wiki: minBy()
@@ -4893,9 +5359,11 @@ public > Observable> minBy(Func1 s
      * resulting Observable emits an empty List.
      * 
    
      * 
-     *
-     * @param selector the key selector function
-     * @param comparator the comparator used to compare key values
+     * 
+     * @param selector
+     *            the key selector function
+     * @param comparator
+     *            the comparator used to compare key values
      * @return an Observable that emits a List of the items emitted by the
      *         source Observable that had the minimum key value according to the
      *         specified comparator
@@ -4912,10 +5380,12 @@ public  Observable> minBy(Func1 selector, Comparator
      * it emits the last-emitted of these.
      * 
    
      * 
-     *
-     * @param source an Observable to scan for the maximum emitted item
+     * 
+     * @param source
+     *            an Observable to scan for the maximum emitted item
      * @return an Observable that emits this maximum item from the source
-     * @throws IllegalArgumentException if the source is empty
+     * @throws IllegalArgumentException
+     *             if the source is empty
      * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
@@ -4929,11 +5399,13 @@ public static > Observable max(Observable
      * one item with the same maximum value, it emits the last-emitted of these.
      * 
    
      * 
-     *
-     * @param comparator the comparer used to compare items
+     * 
+     * @param comparator
+     *            the comparer used to compare items
      * @return an Observable that emits the maximum item emitted by the source
      *         Observable, according to the specified comparator
-     * @throws IllegalArgumentException if the source is empty
+     * @throws IllegalArgumentException
+     *             if the source is empty
      * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
@@ -4947,8 +5419,9 @@ public Observable max(Comparator comparator) {
      * emits no items, the resulting Observable emits an empty List.
      * 
    
      * 
-     *
-     * @param selector the key selector function
+     * 
+     * @param selector
+     *            the key selector function
      * @return an Observable that emits a List of those items emitted by the
      *         source Observable that had the maximum key value
      * @see RxJava Wiki: maxBy()
@@ -4965,9 +5438,11 @@ public > Observable> maxBy(Func1 s
      * Observable emits an empty List.
      * 
    
      * 
-     *
-     * @param selector the key selector function
-     * @param comparator the comparator used to compare key values
+     * 
+     * @param selector
+     *            the key selector function
+     * @param comparator
+     *            the comparator used to compare key values
      * @return an Observable that emits a List of those items emitted by the
      *         source Observable that had the maximum key value according to the
      *         specified comparator
@@ -4992,16 +5467,17 @@ public  Observable> maxBy(Func1 selector, Comparator
     public ConnectableObservable replay() {
         return OperationMulticast.multicast(this, ReplaySubject. create());
     }
-    
+
     /**
      * 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} on the given scheduler.
      * 
    
      * 
-     *
-     * @param scheduler the scheduler on which the Observers will observe the
-     *                  emitted items
+     * 
+     * @param scheduler
+     *            the scheduler on which the Observers will observe the
+     *            emitted items
      * @return a {@link ConnectableObservable} that shares a single subscription
      *         to the source Observable that will replay all of its items and
      *         notifications to any future {@link Observer} on the given
@@ -5010,62 +5486,62 @@ public ConnectableObservable replay() {
      * @see MSDN: Observable.Replay
      */
     public ConnectableObservable replay(Scheduler scheduler) {
-         return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject.create(), scheduler));
+        return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler));
     }
 
     /**
      * Returns a connectable observable sequence that shares a single
-     * subscription to the source Observable that replays at most
-     * {@code bufferSize} items emitted by that Observable.
+     * subscription to the source Observable that replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
      * 
      * 
-     * @param bufferSize the buffer size
-     * @return a connectable observable sequence that shares a single 
-     *         subscription to the source Observable and replays at most
-     *         {@code bufferSize} items emitted by that Observable
+     * @param bufferSize
+     *            the buffer size
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
     public ConnectableObservable replay(int bufferSize) {
-        return OperationMulticast.multicast(this, OperationReplay.replayBuffered(bufferSize));
+        return OperationMulticast.multicast(this, OperationReplay. replayBuffered(bufferSize));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single 
-     * subscription to the source Observable and replays at most
-     * {@code bufferSize} items emitted by that Observable.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
      * 
      * 
-     * @param bufferSize the buffer size
-     * @param scheduler the scheduler on which the Observers will observe the
-     *                  emitted items
-     * @return a connectable observable sequence that shares a single 
-     *         subscription to the source Observable and replays at most
-     *         {@code bufferSize} items emitted by that Observable
+     * @param bufferSize
+     *            the buffer size
+     * @param scheduler
+     *            the scheduler on which the Observers will observe the
+     *            emitted items
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
     public ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
-        return OperationMulticast.multicast(this, 
+        return OperationMulticast.multicast(this,
                 OperationReplay.createScheduledSubject(
-                OperationReplay.replayBuffered(bufferSize), scheduler));
+                        OperationReplay. replayBuffered(bufferSize), scheduler));
     }
-    
+
     /**
-     * Returns a connectable observable sequence that shares a single 
+     * Returns a connectable observable sequence that shares a single
      * subscription to the source Observable and replays all items emitted by
      * that Observable within a time window.
      * 
    
      * 
      * 
-     * @param time the window length
-     * @param unit the window length time unit
-     * @return a connectable observable sequence that shares a single 
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @return a connectable observable sequence that shares a single
      *         subscription to the source Observable and that replays all items
-     *         emitted by that Observable during the window defined by
-     *         {@code time} and {@code unit}
+     *         emitted by that Observable during the window defined by {@code time} and {@code unit}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5074,62 +5550,67 @@ public ConnectableObservable replay(long time, TimeUnit unit) {
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single 
+     * Returns a connectable observable sequence that shares a single
      * subscription to the source Observable and replays all items emitted by
      * that Observable within a time window.
      * 
    
      * 
      * 
-     * @param time the window length
-     * @param unit the window length time unit
-     * @param scheduler the scheduler that is used as a time source for the
-     *                  window
-     * @return a connectable observable sequence that shares a single 
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @param scheduler
+     *            the scheduler that is used as a time source for the
+     *            window
+     * @return a connectable observable sequence that shares a single
      *         subscription to the source Observable and replays all items
-     *         emitted by that Observable within the window defined by
-     *         {@code time} and {@code unit}
+     *         emitted by that Observable within the window defined by {@code time} and {@code unit}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
     public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) {
-        return OperationMulticast.multicast(this, OperationReplay.replayWindowed(time, unit, -1, scheduler));
+        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, -1, scheduler));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence replaying {@code bufferSize}
-     * notifications within window.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
      * 
    
      * 
      * 
-     * @param bufferSize the buffer size
-     * @param time the window length
-     * @param unit the window length time unit
-     * @return Returns a connectable observable sequence that shares a single 
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @return Returns a connectable observable sequence that shares a single
      *         subscription to the underlying sequence replaying bufferSize notifications within window
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
     public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) {
-         return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation());
+        return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence and that replays a maximum of
-     * {@code bufferSize} items that are emitted within the window defined by
-     * {@code time} and {@code unit}.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the underlying sequence and that replays a maximum of {@code bufferSize} items that are emitted within the window defined by {@code time} and {@code unit}.
      * 
    
      * 
      * 
-     * @param bufferSize the buffer size
-     * @param time the window length
-     * @param unit the window length time unit
-     * @param scheduler the scheduler that is used as a time source for the
-     *                  window
-     * @return a connectable observable sequence that shares a single 
-     *         subscription to the underlying sequence that replays a maximum of
-     *         {@code bufferSize} items that are emitted within the window
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @param scheduler
+     *            the scheduler that is used as a time source for the
+     *            window
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence that replays a maximum of {@code bufferSize} items that are emitted within the window
      *         defined by {@code time} and {@code unit}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
@@ -5138,18 +5619,20 @@ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit,
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
-        return OperationMulticast.multicast(this, OperationReplay.replayWindowed(time, unit, bufferSize, scheduler));
+        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, bufferSize, scheduler));
     }
-    
+
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence and starts with initial value.
      * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
      *         single subscription to the underlying sequence and starts with
@@ -5167,16 +5650,19 @@ public Subject call() {
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence replaying all notifications.
      * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param scheduler the scheduler where the replay is observed
-     * @return an observable sequence that is the result of invoking the 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param scheduler
+     *            the scheduler where the replay is observed
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
      *         single subscription to the underlying sequence replaying all
      *         notifications
@@ -5187,26 +5673,27 @@ public  Observable replay(Func1, ? extends Observabl
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.createScheduledSubject(ReplaySubject.create(), scheduler);
+                return OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler);
             }
         }, selector);
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence replaying {@code bufferSize}
-     * notifications.
-     * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param bufferSize the buffer size
-     * @return an observable sequence that is the result of invoking the 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications.
+     * 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying
-     *         {@code bufferSize} notifications
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5220,21 +5707,23 @@ public Subject call() {
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence replaying {@code bufferSize}
-     * notifications.
-     * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param bufferSize the buffer size
-     * @param scheduler the scheduler where the replay is observed
-     * @return an observable sequence that is the result of invoking the 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications.
+     * 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
+     * @param scheduler
+     *            the scheduler where the replay is observed
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying
-     *         {@code bufferSize} notifications
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5242,23 +5731,27 @@ public  Observable replay(Func1, ? extends Observabl
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.createScheduledSubject(OperationReplay.replayBuffered(bufferSize), scheduler);
+                return OperationReplay. createScheduledSubject(OperationReplay. replayBuffered(bufferSize), scheduler);
             }
         }, selector);
     }
 
     /**
      * Returns an observable sequence that is the result of invoking the
-     * selector on a connectable observable sequence that shares a single 
+     * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence replaying all notifications
      * within window.
      * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param time the window length
-     * @param unit the window length time unit
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
      *         single subscription to the underlying sequence replaying all
@@ -5271,20 +5764,25 @@ public  Observable replay(Func1, ? extends Observabl
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence replaying all notifications
      * within window.
      * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param time the window length
-     * @param unit the window length time unit
-     * @param scheduler the scheduler that is used as a time source for the
-     *                  window
-     * @return an observable sequence that is the result of invoking the 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @param scheduler
+     *            the scheduler that is used as a time source for the
+     *            window
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
      *         single subscription to the underlying sequence replaying all
      *         notifications within window
@@ -5301,22 +5799,25 @@ public Subject call() {
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence replaying {@code bufferSize}
-     * notifications within window.
-     * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param bufferSize the buffer size
-     * @param time the window length
-     * @param unit the window length time unit
-     * @return an observable sequence that is the result of invoking the 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
+     * 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying
-     *         {@code bufferSize} notifications within window
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5324,26 +5825,29 @@ public  Observable replay(Func1, ? extends Observabl
         return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
-
     /**
-     * Returns an observable sequence that is the result of invoking the 
-     * selector on a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence replaying {@code bufferSize}
-     * notifications within window.
-     * 
-     * @param  the return element type
-     * @param selector the selector function which can use the multicasted 
-     *                 this sequence as many times as needed, without causing 
-     *                 multiple subscriptions to this sequence
-     * @param bufferSize the buffer size
-     * @param time the window length
-     * @param unit the window length time unit
-     * @param scheduler the scheduler which is used as a time source for the
-     *                  window
-     * @return an observable sequence that is the result of invoking the 
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
+     * 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @param scheduler
+     *            the scheduler which is used as a time source for the
+     *            window
+     * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying
-     *         {@code bufferSize} notifications within window
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5358,7 +5862,7 @@ public Subject call() {
             }
         }, selector);
     }
-    
+
     /**
      * Retry subscription to the source Observable when it calls
      * onError up to a certain number of retries.
@@ -5376,7 +5880,8 @@ public Subject call() {
      * sequence of emissions and notifications would be
      * [1, 2, 1, 2, 3, 4, 5, onCompleted].
      * 
-     * @param retryCount number of retry attempts before failing
+     * @param retryCount
+     *            number of retry attempts before failing
      * @return the source Observable modified with retry logic
      * @see RxJava Wiki: retry()
      */
@@ -5409,14 +5914,12 @@ public Observable retry() {
 
     /**
      * This method has similar behavior to {@link #replay} except that this
-     * auto-subscribes to the source Observable rather than returning a
-     * {@link ConnectableObservable}.
+     * 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.
+     * can't control the subscribe/unsubscribe behavior of all the {@link Observer}s.
      * 
    
      * When you call {@code cache()}, it does not yet subscribe to the
      * source Observable. This only happens when {@code subscribe} is called
@@ -5436,17 +5939,14 @@ public Observable cache() {
     }
 
     /**
-     * Perform work in parallel by sharding an {@code Observable} on a
-     * {@link Schedulers#threadPoolForComputation()} {@link Scheduler} and
+     * Perform work in parallel by sharding an {@code Observable} on a {@link Schedulers#threadPoolForComputation()} {@link Scheduler} and
      * return an {@code Observable} with the output.
      * 
    
      * 
      * 
-     * @param f a {@link Func1} that applies Observable operators to
-     *          {@code Observable} in parallel and returns an
-     *          {@code Observable}
-     * @return an Observable with the output of the {@link Func1} executed on a
-     *         {@link Scheduler}
+     * @param f
+     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
+     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
      * @see RxJava Wiki: parallel()
      */
     public  Observable parallel(Func1, Observable> f) {
@@ -5454,17 +5954,15 @@ public  Observable parallel(Func1, Observable> f) {
     }
 
     /**
-     * Perform work in parallel by sharding an {@code Observable} on a
-     * {@link Scheduler} and return an {@code Observable} with the output.
+     * Perform work in parallel by sharding an {@code Observable} on a {@link Scheduler} and return an {@code Observable} with the output.
      * 
    
      * 
      * 
-     * @param f a {@link Func1} that applies Observable operators to
-     *          {@code Observable} in parallel and returns an
-     *          {@code Observable}
-     * @param s a {@link Scheduler} to perform the work on
-     * @return an Observable with the output of the {@link Func1} executed on a
-     *         {@link Scheduler}
+     * @param f
+     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
+     * @param s
+     *            a {@link Scheduler} to perform the work on
+     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
      * @see RxJava Wiki: parallel()
      */
     public  Observable parallel(final Func1, Observable> f, final Scheduler s) {
@@ -5487,7 +5985,8 @@ public  Observable parallel(final Func1, Observable> f, f
      * 
    
      * 
      * 
-     * @param parallelObservables the number of Observables to merge into
+     * @param parallelObservables
+     *            the number of Observables to merge into
      * @return an Observable of Observables constrained in number by
      *         parallelObservables
      * @see RxJava Wiki: parallelMerge()
@@ -5495,7 +5994,7 @@ public  Observable parallel(final Func1, Observable> f, f
     public static  Observable> parallelMerge(Observable> source, int parallelObservables) {
         return OperationParallelMerge.parallelMerge(source, parallelObservables);
     }
-    
+
     /**
      * Merges an Observable<Observable<T>> to
      * Observable<Observable<T>> with the number of
@@ -5513,8 +6012,10 @@ public static  Observable> parallelMerge(Observable
      * 
      * 
-     * @param parallelObservables the number of Observables to merge into
-     * @param scheduler the Scheduler to run each Observable on
+     * @param parallelObservables
+     *            the number of Observables to merge into
+     * @param scheduler
+     *            the Scheduler to run each Observable on
      * @return an Observable of Observables constrained in number by
      *         parallelObservables
      * @see RxJava Wiki: parallelMerge()
@@ -5522,10 +6023,9 @@ public static  Observable> parallelMerge(Observable Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) {
         return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
     }
-    
+
     /**
-     * Returns a {@link ConnectableObservable}, which waits until its
-     * {@link ConnectableObservable#connect connect} method is called before it
+     * 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.
      * 
    
@@ -5542,26 +6042,31 @@ public ConnectableObservable publish() {
     /**
      * Create a connectable observable sequence that shares a single
      * subscription to the underlying sequence and starts with initialValue.
-     * @param initialValue the initial value of the underlying BehaviorSubject
+     * 
+     * @param initialValue
+     *            the initial value of the underlying BehaviorSubject
      * @return a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
      */
     public ConnectableObservable publish(T initialValue) {
         return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
     }
-    
+
     /**
      * Create an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence.
-     * @param  the result type
-     * @param selector function which can use the multicasted source
-     * sequence as many times as needed, without causing multiple
-     * subscriptions to the source sequence. Subscribers to the given
-     * source will receive all notifications of the source from the time
-     * of the subscription on.
+     * 
+     * @param 
+     *            the result type
+     * @param selector
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will receive all notifications of the source from the time
+     *            of the subscription on.
      * @return an observable sequence that is the result of invoking the
-     * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence.
+     *         selector on a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence.
      */
     public  Observable publish(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
@@ -5571,17 +6076,23 @@ public Subject call() {
             }
         }, selector);
     }
-    
+
     /**
-     * Create an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
-     * @param  the result type
-     * @param selector function which can use the multicasted source
-     * sequence as many times as needed, without causing multiple
-     * subscriptions to the source sequence. Subscribers to the given
-     * source will receive all notifications of the source from the time
-     * of the subscription on
-     * @param initialValue the initial value of the underlying BehaviorSubject
-     * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue
+     * Create an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
+     * initialValue.
+     * 
+     * @param 
+     *            the result type
+     * @param selector
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will receive all notifications of the source from the time
+     *            of the subscription on
+     * @param initialValue
+     *            the initial value of the underlying BehaviorSubject
+     * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
+     *         initialValue
      */
     public  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
         return multicast(new Func0>() {
@@ -5591,7 +6102,7 @@ public Subject call() {
             }
         }, selector);
     }
-    
+
     /**
      * Returns a {@link ConnectableObservable} that emits only the last item
      * emitted by the source Observable.
@@ -5604,21 +6115,24 @@ public Subject call() {
     public ConnectableObservable publishLast() {
         return OperationMulticast.multicast(this, AsyncSubject. create());
     }
-    
+
     /**
      * Create an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
      * subscription to the underlying sequence containing only the last
      * notification.
-     * @param  the result type
-     * @param selector function which can use the multicasted source
-     * sequence as many times as needed, without causing multiple
-     * subscriptions to the source sequence. Subscribers to the given
-     * source will only receive the last notification of the source
+     * 
+     * @param 
+     *            the result type
+     * @param selector
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will only receive the last notification of the source
      * @return an observable sequence that is the result of invoking the
-     * selector on a connectable observable sequence that shares a single 
-     * subscription to the underlying sequence containing only the last
-     * notification.
+     *         selector on a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence containing only the last
+     *         notification.
      */
     public  Observable publishLast(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
@@ -5633,7 +6147,7 @@ public Subject call() {
      * Synonymous with reduce().
      * 
    
      * 
-     *
+     * 
      * @see RxJava Wiki: reduce()
      * @see #reduce(Func2)
      * @deprecated use #reduce(Func2)
@@ -5658,10 +6172,12 @@ public Observable aggregate(Func2 accumulator) {
      * 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
+     * @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
@@ -5672,7 +6188,7 @@ public Observable aggregate(Func2 accumulator) {
     public  Observable reduce(R initialValue, Func2 accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
-    
+
     /**
      * Collect values into a single mutable data structure.
      * 
    
@@ -5695,7 +6211,7 @@ public R call(R state, T value) {
         };
         return reduce(state, accumulator);
     }
-    
+
     /**
      * Synonymous with reduce().
      * 
    
@@ -5709,7 +6225,7 @@ public R call(R state, T value) {
     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
@@ -5721,11 +6237,11 @@ public  Observable aggregate(R initialValue, Func2 accumu
      * 
    
      * This sort of function is sometimes called an accumulator.
      * 
-     * @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
+     * @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 RxJava Wiki: scan()
@@ -5741,8 +6257,10 @@ public Observable scan(Func2 accumulator) {
      * 
    
      * 
      * 
-     * @param period the sampling rate
-     * @param unit the {@link TimeUnit} in which period is defined
+     * @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
      * @see RxJava Wiki: sample()
@@ -5757,9 +6275,12 @@ public Observable sample(long period, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param period the sampling rate
-     * @param unit the {@link TimeUnit} in which period is defined
-     * @param scheduler the {@link Scheduler} to use when sampling
+     * @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
      * @see RxJava Wiki: sample()
@@ -5767,7 +6288,7 @@ public Observable sample(long period, TimeUnit unit) {
     public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
         return create(OperationSample.sample(this, period, unit, scheduler));
     }
-    
+
     /**
      * Return an Observable that emits the results of sampling the items emitted
      * by this Observable when the sampler Observable emits an item
@@ -5775,7 +6296,8 @@ public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
      * 
    
      * 
      * 
-     * @param sampler the Observable to use for sampling the source Observable
+     * @param sampler
+     *            the Observable to use for sampling the source Observable
      * @return an Observable that emits the results of sampling the items
      *         emitted by this Observable whenever the sampler
      *         Observable emits an item or completes
@@ -5784,7 +6306,7 @@ public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
     public  Observable sample(Observable sampler) {
         return create(new OperationSample.SampleWithObservable(this, sampler));
     }
-    
+
     /**
      * 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
@@ -5799,12 +6321,13 @@ public  Observable sample(Observable sampler) {
      * 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 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
+     * @param initialValue
+     *            the initial (seed) accumulator 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 RxJava Wiki: scan()
@@ -5820,7 +6343,8 @@ public  Observable scan(R initialValue, Func2 accumulator
      * 
    
      * 
      * 
-     * @param predicate a function that evaluates an item and returns a Boolean
+     * @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
@@ -5836,7 +6360,8 @@ public Observable all(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param num the number of items to skip
+     * @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 Observable emits
@@ -5851,24 +6376,29 @@ public Observable skip(int num) {
      * 
    
      * 
      * 
-     * @param time the length of the time window
-     * @param unit the time unit
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
      * @return an Observable that skips values before the given time ellapses
      * @see RxJava Wiki: skip()
      */
     public Observable skip(long time, TimeUnit unit) {
         return skip(time, unit, Schedulers.threadPoolForComputation());
     }
- 
+
     /**
      * Create an Observable that skips values before the given time elapses
      * while waiting on the given scheduler.
      * 
    
      * 
      * 
-     * @param time the length of the time window
-     * @param unit the time unit
-     * @param scheduler the scheduler where the timed wait happens
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler where the timed wait happens
      * @return an Observable that skips values before the given time elapses
      *         while waiting on the given scheduler
      * @see RxJava Wiki: skip()
@@ -5876,7 +6406,7 @@ public Observable skip(long time, TimeUnit unit) {
     public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
     }
- 
+
     /**
      * If the Observable completes after emitting a single item, return an
      * Observable containing that item. If it emits more than one item or no
@@ -5886,8 +6416,9 @@ public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
      * 
      * @return an Observable that emits the single item emitted by the source
      *         Observable that matches the predicate
-     * @throws IllegalArgumentException if the source emits more than one item
-     *                                  or no items
+     * @throws IllegalArgumentException
+     *             if the source emits more than one item
+     *             or no items
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleAsync()
      */
@@ -5903,13 +6434,15 @@ public Observable single() {
      * 
    
      * 
      * 
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  source Observable
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the
+     *            source Observable
      * @return an Observable that emits the single item emitted by the source
      *         Observable that matches the predicate
-     * @throws IllegalArgumentException if the source Observable emits more than
-     *                                  one item or no items matching the
-     *                                  predicate
+     * @throws IllegalArgumentException
+     *             if the source Observable emits more than
+     *             one item or no items matching the
+     *             predicate
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleAsync()
      */
@@ -5925,11 +6458,13 @@ public Observable single(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to emit if the source Observable
-     *                     emits no item
+     * @param defaultValue
+     *            a default value to emit if the source Observable
+     *            emits no item
      * @return an Observable that emits the single item emitted by the source
      *         Observable, or default value if the source Observable is empty
-     * @throws IllegalArgumentException if the source emits more than one item
+     * @throws IllegalArgumentException
+     *             if the source emits more than one item
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleOrDefaultAsync()
      */
@@ -5946,15 +6481,18 @@ public Observable singleOrDefault(T defaultValue) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to emit if the source Observable
-     *                     emits no matching items
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  source Observable
+     * @param defaultValue
+     *            a default value to emit if the source Observable
+     *            emits no matching items
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the
+     *            source Observable
      * @return an Observable that emits the single item emitted by the source
      *         Observable that matches the predicate, or the default item if no
      *         emitted item matches the predicate
-     * @throws IllegalArgumentException if the source emits more than one item
-     *                                  matching the predicate
+     * @throws IllegalArgumentException
+     *             if the source emits more than one item
+     *             matching the predicate
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleOrDefaultAsync()
      */
@@ -5985,7 +6523,8 @@ public Observable first() {
      * 
    
      * 
      * 
-     * @param predicate the condition any source emitted item has to satisfy
+     * @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 an IllegalArgumentException if no such items are emitted.
      * @see RxJava Wiki: first()
@@ -6001,8 +6540,9 @@ public Observable first(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param defaultValue the default item to emit if the source Observable
-     *                     doesn't emit anything
+     * @param defaultValue
+     *            the default item 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 item if the source Observable completes
      *         without emitting a single item
@@ -6020,9 +6560,11 @@ public Observable firstOrDefault(T defaultValue) {
      * 
    
      * 
      * 
-     * @param predicate the condition any source emitted item has to satisfy
-     * @param defaultValue the default item to emit if the source Observable
-     *        doesn't emit anything that satisfies the given condition
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
+     * @param defaultValue
+     *            the default item 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 item otherwise
      * @see RxJava Wiki: firstOrDefault()
@@ -6038,8 +6580,9 @@ public Observable firstOrDefault(T defaultValue, Func1 pr
      * 
    
      * 
      * 
-     * @param defaultValue the item to emit if the source Observable emits no
-     *                     items
+     * @param defaultValue
+     *            the item to emit if the source Observable emits no
+     *            items
      * @return an Observable that emits either the specified default item if the
      *         source Observable emits no items, or the items emitted by the
      *         source Observable
@@ -6056,12 +6599,11 @@ public Observable defaultIfEmpty(T defaultValue) {
      * 
    
      * 
      * 
    
-     * 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}.
+     * 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 emit
+     * @param num
+     *            the number of items to emit
      * @return an Observable that emits only the first num items
      *         emitted by the source Observable, or all of the items from the
      *         source Observable if that Observable emits fewer than
@@ -6078,8 +6620,10 @@ public Observable take(final int num) {
      * 
    
      * 
      * 
-     * @param time the length of the time window
-     * @param unit the time unit
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
      * @return an Observable that emits the emitted items from the source
      *         Observable before the time runs out
      * @see RxJava Wiki: take()
@@ -6087,16 +6631,19 @@ public Observable take(final int num) {
     public Observable take(long time, TimeUnit unit) {
         return take(time, unit, Schedulers.threadPoolForComputation());
     }
-     
+
     /**
      * Create an Observable that emits the emitted items from the source
      * Observable before the time runs out, waiting on the given scheduler.
      * 
    
      * 
      * 
-     * @param time the length of the time window
-     * @param unit the time unit
-     * @param scheduler the scheduler used for time source
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler used for time source
      * @return an Observable that emits the emitted items from the source
      *         Observable before the time runs out, waiting on the given
      *         scheduler
@@ -6105,15 +6652,16 @@ public Observable take(long time, TimeUnit unit) {
     public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
     }
- 
+
     /**
      * 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
+     * @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
@@ -6131,9 +6679,10 @@ public Observable takeWhile(final Func1 predicate) {
      * 
    
      * 
      * 
-     * @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
+     * @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
@@ -6167,7 +6716,8 @@ public Observable takeFirst() {
      * 
    
      * 
      * 
-     * @param predicate the condition any source emitted item has to satisfy
+     * @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 an empty Observable if the
      *         source Observable completes without emitting a single matching
@@ -6185,8 +6735,9 @@ public Observable takeFirst(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param count the number of items to emit from the end of the sequence
-     *              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
      * @see RxJava Wiki: takeLast()
@@ -6201,16 +6752,18 @@ public Observable takeLast(final int count) {
      * 
    
      * 
      * 
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
      * @return an Observable that emits the items from the source Observable
      *         that were emitted not before it completed minus a time window
      */
     public Observable takeLast(long time, TimeUnit unit) {
         return takeLast(time, unit, Schedulers.threadPoolForComputation());
     }
-    
+
     /**
      * Return an Observable that emits the items from the source Observable that
      * were emitted not before the source Observable completed minus a time
@@ -6218,11 +6771,14 @@ public Observable takeLast(long time, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
-     * @param scheduler the Scheduler that provides the timestamps for the
-     *                  Observed items
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            Observed items
      * @return an Observable that emits the items from the source Observable
      *         that were emitted not before it completed minus a time window,
      *         where the timing information is provided by the given Scheduler
@@ -6230,7 +6786,7 @@ public Observable takeLast(long time, TimeUnit unit) {
     public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
     }
-    
+
     /**
      * Return an Observable that emits at most a specified number of items from
      * the source Observable that were emitted not before it completed minus a
@@ -6238,10 +6794,13 @@ public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
      * 
    
      * 
      * 
-     * @param count the maximum number of items to emit
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
      * @return an Observable that emits at most {@code count} items from the
      *         source Observable which were emitted not before it completed
      *         minus a time window
@@ -6258,12 +6817,16 @@ public Observable takeLast(int count, long time, TimeUnit unit) {
      * 
    
      * 
      * 
-     * @param count the maximum number of items to emit
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
-     * @param scheduler the Scheduler that provides the timestamps for the
-     *                  observed items
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            observed items
      * @return an Observable that emits at most {@code count} items from the
      *         source Observable which were emitted not before it completed
      *         minus a time window, where the timing information is provided by
@@ -6277,29 +6840,30 @@ public Observable takeLast(int count, long time, TimeUnit unit, Scheduler sch
     }
 
     /**
-     * Return an Observable that emits single List containing the last
-     * {@code count} elements emitted by the source Observable.
+     * Return an Observable that emits single List containing the last {@code count} elements emitted by the source Observable.
      * 
    
      * 
      * 
-     * @param count the number of items to take last
-     * @return an Observable that emits a single list containing the last
-     *         {@code count} elements emitted by the source Observable
+     * @param count
+     *            the number of items to take last
+     * @return an Observable that emits a single list containing the last {@code count} elements emitted by the source Observable
      */
     public Observable> takeLastBuffer(int count) {
         return takeLast(count).toList();
     }
-    
+
     /**
      * Return an Observable that emits single List containing items that were
      * emitted by the source Observable not before it completed minus a time
      * window.
      * 
    
      * 
-     *
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
+     * 
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
      * @return an Observable that emits single list containing items that were
      *         were emitted by the source Observable not before it completed
      *         minus a time window
@@ -6314,12 +6878,15 @@ public Observable> takeLastBuffer(long time, TimeUnit unit) {
      * window, where the timing information is provided by the given Scheduler.
      * 
    
      * 
-     *
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
-     * @param scheduler the Scheduler that provides the timestamps for the
-     *                  observed items
+     * 
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            observed items
      * @return an Observable that emits single list containing items that were
      *         were emitted by the source Observable not before it completed
      *         minus a time window, where the timing information is provided by
@@ -6330,18 +6897,19 @@ public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler sc
     }
 
     /**
-     * Return an Observable that emits a single List containing at most
-     * {@code count} items from the source Observable that were emitted not
+     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
      * before it completed minus a time window.
      * 
    
      * 
-     *
-     * @param count the maximum number of items to emit
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
-     * @return an Observable that emits a single List containing at most
-     *         {@code count} items emitted by the source Observable not before
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
      *         it completed minus a time window
      */
     public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
@@ -6349,26 +6917,27 @@ public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
     }
 
     /**
-     * Return an Observable that emits a single List containing at most
-     * {@code count} items from the source Observable that were emitted not
+     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
      * before it completed minus a time window.
      * 
    
      * 
-     *
-     * @param count the maximum number of items to emit
-     * @param time the length of the time window, relative to the completion of
-     *             the source Observable
-     * @param unit the time unit
-     * @param scheduler the scheduler that provides the timestamps for the
-     *                  observed items
-     * @return an Observable that emits a single List containing at most
-     *         {@code count} items emitted by the source Observable not before
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler that provides the timestamps for the
+     *            observed items
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
      *         it completed minus a time window
      */
     public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(count, time, unit, scheduler).toList();
     }
-    
 
     /**
      * Returns an Observable that emits the items from the source Observable
@@ -6376,10 +6945,12 @@ public Observable> takeLastBuffer(int count, long time, TimeUnit unit, S
      * 
    
      * 
      * 
-     * @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
+     * @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
      * @see RxJava Wiki: takeUntil()
@@ -6395,10 +6966,11 @@ public  Observable takeUntil(Observable other) {
      * 
    
      * 
      * 
-     * @param predicate a function to test each item emitted from the source
-     *                  Observable for a condition. It receives the emitted item
-     *                  as the first parameter and the index of the emitted item
-     *                  as a second parameter.
+     * @param predicate
+     *            a function to test each item emitted from the source
+     *            Observable for a condition. It receives the emitted item
+     *            as the first parameter and the index of the emitted item
+     *            as a second parameter.
      * @return an Observable that emits all items from the source Observable as
      *         soon as the condition becomes false
      * @see RxJava Wiki: skipWhileWithIndex()
@@ -6415,8 +6987,9 @@ public Observable skipWhileWithIndex(Func2 predi
      * 
    
      * 
      * 
-     * @param predicate a function to test each item emitted from the source
-     *                  Observable for a condition
+     * @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 RxJava Wiki: skipWhile()
@@ -6437,10 +7010,12 @@ public Observable skipWhile(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param count number of items to bypass at the end of the source sequence
+     * @param count
+     *            number of items to bypass at the end of the source sequence
      * @return an Observable that emits the items emitted by the source
      *         Observable except for the bypassed ones at the end
-     * @throws IndexOutOfBoundsException if count is less than zero
+     * @throws IndexOutOfBoundsException
+     *             if count is less than zero
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
@@ -6453,9 +7028,11 @@ public Observable skipLast(int count) {
      * the source completes.
      * 
    
      * 
-     *
-     * @param time the length of the time window
-     * @param unit the time unit
+     * 
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
      * @return an Observable that skips values emitted in a time window before
      *         the source completes
      * @see RxJava Wiki: skipLast()
@@ -6464,16 +7041,19 @@ public Observable skipLast(int count) {
     public Observable skipLast(long time, TimeUnit unit) {
         return skipLast(time, unit, Schedulers.threadPoolForComputation());
     }
-    
+
     /**
      * Create an Observable that skips values emitted in a time window before
      * the source completes by using the given scheduler as time source.
      * 
    
      * 
-     *
-     * @param time the length of the time window
-     * @param unit the time unit
-     * @param scheduler the scheduler used for time source
+     * 
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler used for time source
      * @return an Observable that skips values emitted in a time window before
      *         the source completes by using the given scheduler as time source
      * @see RxJava Wiki: skipLast()
@@ -6482,7 +7062,7 @@ public Observable skipLast(long time, TimeUnit unit) {
     public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
     }
- 
+
     /**
      * Returns an Observable that emits a single item, a list composed of all
      * the items emitted by the source Observable.
@@ -6494,8 +7074,7 @@ public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
      * 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.
+     * 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
@@ -6517,9 +7096,10 @@ public Observable> toList() {
      * 
    
      * 
      * 
-     * @throws ClassCastException if any item emitted by the Observable does not
-     *                            implement {@link Comparable} with respect to
-     *                            all other items emitted by the Observable
+     * @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
      * @see RxJava Wiki: toSortedList()
@@ -6534,9 +7114,10 @@ public Observable> toSortedList() {
      * 
    
      * 
      * 
-     * @param sortFunction a function that compares two items emitted by the
-     *                     source Observable and returns an Integer that
-     *                     indicates their sort order
+     * @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
      * @see RxJava Wiki: toSortedList()
@@ -6551,8 +7132,9 @@ public Observable> toSortedList(Func2 sor
      * 
    
      * 
      * 
-     * @param values Iterable of the items you want the modified Observable to
-     *               emit first
+     * @param values
+     *            Iterable of the items you want the modified Observable to
+     *            emit first
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6566,9 +7148,11 @@ public Observable startWith(Iterable values) {
      * 
    
      * 
      * 
-     * @param values iterable of the items you want the modified Observable to
-     *               emit first
-     * @param scheduler the scheduler to emit the prepended values on
+     * @param values
+     *            iterable of the items you want the modified Observable to
+     *            emit first
+     * @param scheduler
+     *            the scheduler to emit the prepended values on
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
@@ -6582,9 +7166,11 @@ public Observable startWith(Iterable values, Scheduler scheduler) {
      * beginning to emit items from the source Observable.
      * 
    
      * 
-     *
-     * @param values the items you want the modified Observable to emit first
-     * @param scheduler the scheduler to emit the prepended values on
+     * 
+     * @param values
+     *            the items you want the modified Observable to emit first
+     * @param scheduler
+     *            the scheduler to emit the prepended values on
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
@@ -6599,7 +7185,8 @@ public Observable startWith(T[] values, Scheduler scheduler) {
      * 
    
      * 
      * 
-     * @param t1 item to emit
+     * @param t1
+     *            item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6613,8 +7200,10 @@ public Observable startWith(T t1) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6628,9 +7217,12 @@ public Observable startWith(T t1, T t2) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6644,10 +7236,14 @@ public Observable startWith(T t1, T t2, T t3) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6661,11 +7257,16 @@ public Observable startWith(T t1, T t2, T t3, T t4) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
-     * @param t5 fifth item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6679,12 +7280,18 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
-     * @param t5 fifth item to emit
-     * @param t6 sixth item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6698,13 +7305,20 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
-     * @param t5 fifth item to emit
-     * @param t6 sixth item to emit
-     * @param t7 seventh item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6718,14 +7332,22 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
-     * @param t5 fifth item to emit
-     * @param t6 sixth item to emit
-     * @param t7 seventh item to emit
-     * @param t8 eighth item to emit 
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
+     * @param t8
+     *            eighth item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6739,15 +7361,24 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
      * 
    
      * 
      * 
-     * @param t1 first item to emit
-     * @param t2 second item to emit
-     * @param t3 third item to emit
-     * @param t4 fourth item to emit
-     * @param t5 fifth item to emit
-     * @param t6 sixth item to emit
-     * @param t7 seventh item to emit
-     * @param t8 eighth item to emit 
-     * @param t9 ninth item to emit
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
+     * @param t8
+     *            eighth item to emit
+     * @param t9
+     *            ninth item to emit
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
@@ -6762,12 +7393,14 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T
      * 
    
      * 
      * 
-     * @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
+     * @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
@@ -6785,8 +7418,10 @@ public  Observable> groupBy(final Func1
      * 
      * 
-     * @param keySelector a function that extracts the key for each item
-     * @param  the key type
+     * @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
@@ -6803,28 +7438,32 @@ public  Observable> groupBy(final Func1
      * 
      * 
-     * @param right the other Observable to correlate items from this Observable
-     *              with
-     * @param leftDuration function that returns an Observable whose emissions
-     *                     indicate the duration of the values of this
-     *                     Observable
-     * @param rightDuration function that returns an Observable whose emissions
-     *                      indicate the duration of the values of the
-     *                      right Observable
-     * @param resultSelector function that takes an item emitted by each source
-     *                       Observable and returns the value to be emitted by
-     *                       the resulting Observable
+     * @param right
+     *            the other Observable to correlate items from this Observable
+     *            with
+     * @param leftDuration
+     *            function that returns an Observable whose emissions
+     *            indicate the duration of the values of this
+     *            Observable
+     * @param rightDuration
+     *            function that returns an Observable whose emissions
+     *            indicate the duration of the values of the
+     *            right Observable
+     * @param resultSelector
+     *            function that takes an item emitted by each source
+     *            Observable and returns the value to be emitted by
+     *            the resulting Observable
      * @return an Observable that emits grouped items based on overlapping
      *         durations from this and another Observable
      * @see RxJava Wiiki: groupJoin
      * @see MSDN: Observable.GroupJoin
      */
-    public  Observable groupJoin(Observable right, Func1> leftDuration, 
+    public  Observable groupJoin(Observable right, Func1> leftDuration,
             Func1> rightDuration,
             Func2, ? extends R> resultSelector) {
         return create(new OperationGroupJoin(this, right, leftDuration, rightDuration, resultSelector));
     }
-    
+
     /**
      * Returns an Observable that emits true if the source
      * Observable is empty, otherwise false.
@@ -6865,11 +7504,13 @@ public Observable last() {
      * 
    
      * 
      * 
-     * @param predicate the condition any source emitted item has to satisfy
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item satisfying the given
      *         condition from the source, or an IllegalArgumentException if no
      *         such items are emitted
-     * @throws IllegalArgumentException if no such itmes are emmited
+     * @throws IllegalArgumentException
+     *             if no such itmes are emmited
      * @see RxJava Wiki: last()
      * @see MSDN: Observable.lastAsync()
      */
@@ -6883,8 +7524,9 @@ public Observable last(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param defaultValue the default item to emit if the source Observable is
-     *                     empty
+     * @param defaultValue
+     *            the default item to emit if the source Observable is
+     *            empty
      * @return an Observable that emits only the last item from the source, or a
      *         default item if the source is empty
      * @see RxJava Wiki: lastOrDefault()
@@ -6900,10 +7542,12 @@ public Observable lastOrDefault(T defaultValue) {
      * 
    
      * 
      * 
-     * @param defaultValue the default item to emit if the source Observable
-     *                     doesn't emit anything that satisfies the given
-     *                     condition
-     * @param predicate the condition any source emitted item has to satisfy
+     * @param defaultValue
+     *            the default item to emit if the source Observable
+     *            doesn't emit anything that satisfies the given
+     *            condition
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item from the source that
      *         satisfies the given condition, or a default item otherwise
      * @see RxJava Wiki: lastOrDefault()
@@ -6920,7 +7564,7 @@ public Observable lastOrDefault(T defaultValue, Func1 pre
      * 
      * 
      * @return an Observable that emits the number of items emitted by the
-     *         source Observable as its single, 64-bit long item 
+     *         source Observable as its single, 64-bit long item
      * @see RxJava Wiki: count()
      * @see MSDN: Observable.LongCount
      * @see #count()
@@ -6933,7 +7577,7 @@ public Long call(Long t1, T t2) {
             }
         });
     }
-    
+
     /**
      * Converts an Observable into a {@link BlockingObservable} (an Observable
      * with blocking operators).
@@ -6950,7 +7594,8 @@ public BlockingObservable toBlockingObservable() {
      * 
    
      * 
      * 
-     * @param klass the target class type which the items will be converted to
+     * @param klass
+     *            the target class type which the items will be converted to
      * @return an Observable that emits each item from the source Observable
      *         converted to the specified type
      * @see RxJava Wiki: cast()
@@ -6965,8 +7610,9 @@ public  Observable cast(final Class klass) {
      * 
    
      * 
      * 
-     * @param klass the class type to filter the items emitted by the source
-     *              Observable
+     * @param klass
+     *            the class type to filter the items emitted by the source
+     *            Observable
      * @return an Observable that emits items from the source Observable of
      *         type klass.
      * @see RxJava Wiki: ofType()
@@ -7002,10 +7648,12 @@ public Observable ignoreElements() {
      * predecessor, observers are notified of a TimeoutException.
      * 
    
      * 
-     *
-     * @param timeout maximum duration between items before a timeout occurs
-     * @param timeUnit the unit of time which applies to the
-     *                 timeout argument.
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument.
      * @return the source Observable modified to notify observers of a
      *         TimeoutException in case of a timeout
      * @see RxJava Wiki: timeout()
@@ -7023,11 +7671,14 @@ public Observable timeout(long timeout, TimeUnit timeUnit) {
      * notifications from that point on.
      * 
    
      * 
-     *
-     * @param timeout maximum duration between items before a timeout occurs
-     * @param timeUnit the unit of time which applies to the
-     *                 timeout argument
-     * @param other fallback Observable to use in case of a timeout
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param other
+     *            fallback Observable to use in case of a timeout
      * @return the source Observable modified to switch to the fallback
      *         Observable in case of a timeout
      * @see RxJava Wiki: timeout()
@@ -7044,11 +7695,14 @@ public Observable timeout(long timeout, TimeUnit timeUnit, ObservableTimeoutException.
      * 
    
      * 
-     *
-     * @param timeout maximum duration between items before a timeout occurs
-     * @param timeUnit the unit of time which applies to the
-     *                 timeout argument
-     * @param scheduler Scheduler to run the timeout timers on
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param scheduler
+     *            Scheduler to run the timeout timers on
      * @return the source Observable modified to notify observers of a
      *         TimeoutException in case of a timeout
      * @see RxJava Wiki: timeout()
@@ -7066,12 +7720,16 @@ public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler schedule
      * items and notifications from that point on.
      * 
    
      * 
-     *
-     * @param timeout maximum duration between items before a timeout occurs
-     * @param timeUnit the unit of time which applies to the
-     *                 timeout argument
-     * @param other Observable to use as the fallback in case of a timeout
-     * @param scheduler Scheduler to run the timeout timers on
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param other
+     *            Observable to use as the fallback in case of a timeout
+     * @param scheduler
+     *            Scheduler to run the timeout timers on
      * @return the source Observable modified so that it will switch to the
      *         fallback Observable in case of a timeout
      * @see RxJava Wiki: timeout()
@@ -7082,33 +7740,40 @@ public Observable timeout(long timeout, TimeUnit timeUnit, Observable
      * The arrival of the first source item is not timed out.
-     * @param  the timeout value type (ignored)
-     * @param timeoutSelector function that returns an observable for each source item
-     * which determines the timeout window for the subsequent source item
-     * @return an observable which completes if a source item doesn't arrive after the 
-     * previous one in the time window specified by the per-item observable.
+     * 
+     * @param 
+     *            the timeout value type (ignored)
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
+     * @return an observable which completes if a source item doesn't arrive after the
+     *         previous one in the time window specified by the per-item observable.
      */
     public  Observable timeout(Func1> timeoutSelector) {
-        return timeout(timeoutSelector, Observable.empty());
+        return timeout(timeoutSelector, Observable. empty());
     }
 
     /**
-     * Create an observable which switches to the other Observable if a source 
-     * item doesn't arrive after the 
+     * Create an observable which switches to the other Observable if a source
+     * item doesn't arrive after the
      * previous one in the time window specified by the per-item observable.
      * 
    
      * The arrival of the first source item is not timed out.
-     * @param  the timeout value type (ignored)
-     * @param timeoutSelector function that returns an observable for each source item
-     * which determines the timeout window for the subsequent source item
-     * @param other the other observable to switch to if the source times out
-     * @return an observable which switches to the other Observable if a source 
-     * item doesn't arrive after the 
-     * previous one in the time window specified by the per-item observable
+     * 
+     * @param 
+     *            the timeout value type (ignored)
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
+     * @param other
+     *            the other observable to switch to if the source times out
+     * @return an observable which switches to the other Observable if a source
+     *         item doesn't arrive after the
+     *         previous one in the time window specified by the per-item observable
      */
     public  Observable timeout(Func1> timeoutSelector, Observable other) {
         if (other == null) {
@@ -7120,36 +7785,47 @@ public  Observable timeout(Func1> timeo
     /**
      * Create an Observable which completes if either the first item or any subsequent item
      * doesn't arrive within the time window specified by the timeout selectors' Observable.
-     * @param  the first timeout value type (ignored)
-     * @param  the subsequent timeout value type (ignored)
-     * @param firstTimeoutSelector function that returns an observable which determines
-     * the timeout window for the first source item
-     * @param timeoutSelector function that returns an observable for each source item
-     * which determines the timeout window for the subsequent source item
+     * 
+     * @param 
+     *            the first timeout value type (ignored)
+     * @param 
+     *            the subsequent timeout value type (ignored)
+     * @param firstTimeoutSelector
+     *            function that returns an observable which determines
+     *            the timeout window for the first source item
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
      * @return an Observable which completes if either the first item or any subsequent item
-     * doesn't arrive within the time window specified by the timeout selectors' Observable.
+     *         doesn't arrive within the time window specified by the timeout selectors' Observable.
      */
     public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
         if (firstTimeoutSelector == null) {
             throw new NullPointerException("firstTimeoutSelector");
         }
-        return timeout(firstTimeoutSelector, timeoutSelector, Observable.empty());
+        return timeout(firstTimeoutSelector, timeoutSelector, Observable. empty());
     }
 
     /**
      * Create an Observable which switches to another Observable
      * if either the first item or any subsequent item
      * doesn't arrive within the time window specified by the timeout selectors' Observable.
-     * @param  the first timeout value type (ignored)
-     * @param  the subsequent timeout value type (ignored)
-     * @param firstTimeoutSelector function that returns an observable which determines
-     * the timeout window for the first source item
-     * @param timeoutSelector function that returns an observable for each source item
-     * which determines the timeout window for the subsequent source item
-     * @param other the other observable to switch to if the source times out
+     * 
+     * @param 
+     *            the first timeout value type (ignored)
+     * @param 
+     *            the subsequent timeout value type (ignored)
+     * @param firstTimeoutSelector
+     *            function that returns an observable which determines
+     *            the timeout window for the first source item
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
+     * @param other
+     *            the other observable to switch to if the source times out
      * @return an Observable which switches to another Observable
-     * if either the first item or any subsequent item
-     * doesn't arrive within the time window specified by the timeout selectors' Observable
+     *         if either the first item or any subsequent item
+     *         doesn't arrive within the time window specified by the timeout selectors' Observable
      */
     public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
         if (firstTimeoutSelector == null) {
@@ -7181,7 +7857,8 @@ public Observable> timeInterval() {
      * 
    
      * 
      * 
-     * @param scheduler Scheduler used to compute time intervals
+     * @param scheduler
+     *            Scheduler used to compute time intervals
      * @return an Observable that emits time interval information items
      * @see RxJava Wiki: timeInterval()
      * @see MSDN: Observable.TimeInterval
@@ -7194,10 +7871,12 @@ public Observable> timeInterval(Scheduler scheduler) {
      * Constructs an Observable that creates a dependent resource object.
      * 
    
      * 
-     *
-     * @param resourceFactory the factory function to obtain a resource object
-     *                        that depends on the Observable
-     * @param observableFactory the factory function to obtain an Observable
+     * 
+     * @param resourceFactory
+     *            the factory function to obtain a resource object
+     *            that depends on the Observable
+     * @param observableFactory
+     *            the factory function to obtain an Observable
      * @return the Observable whose lifetime controls the lifetime of the
      *         dependent resource object
      * @see RxJava Wiki: using()
@@ -7211,9 +7890,11 @@ public static  Observable using(Func0
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7227,10 +7908,13 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7244,11 +7928,15 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7262,12 +7950,17 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
-     * @param o5 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7281,13 +7974,19 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
-     * @param o5 an Observable competing to react first
-     * @param o6 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7301,14 +8000,21 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
-     * @param o5 an Observable competing to react first
-     * @param o6 an Observable competing to react first
-     * @param o7 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7322,15 +8028,23 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
-     * @param o5 an Observable competing to react first
-     * @param o6 an Observable competing to react first
-     * @param o7 an Observable competing to react first
-     * @param o8 an observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
+     * @param o8
+     *            an observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7344,16 +8058,25 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param o1 an Observable competing to react first
-     * @param o2 an Observable competing to react first
-     * @param o3 an Observable competing to react first
-     * @param o4 an Observable competing to react first
-     * @param o5 an Observable competing to react first
-     * @param o6 an Observable competing to react first
-     * @param o7 an Observable competing to react first
-     * @param o8 an Observable competing to react first
-     * @param o9 an Observable competing to react first
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
+     * @param o8
+     *            an Observable competing to react first
+     * @param o9
+     *            an Observable competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7367,8 +8090,9 @@ public static  Observable amb(Observable o1, Observable
      * 
-     *
-     * @param sources Observable sources competing to react first
+     * 
+     * @param sources
+     *            Observable sources competing to react first
      * @return an Observable that reflects whichever of the given Observables
      *         reacted first
      * @see RxJava Wiki: amb()
@@ -7382,9 +8106,10 @@ public static  Observable amb(Iterable>
      * Invokes an action for each item emitted by the Observable.
      * 
    
      * 
-     *
-     * @param observer the action to invoke for each item emitted by the source
-     *                 Observable
+     * 
+     * @param observer
+     *            the action to invoke for each item emitted by the source
+     *            Observable
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnEach()
      * @see MSDN: Observable.Do
@@ -7397,9 +8122,10 @@ public Observable doOnEach(Observer observer) {
      * Invokes an action if the source Observable calls onError.
      * 
    
      * 
-     *
-     * @param onError the action to invoke if the source Observable calls
-     *                onError
+     * 
+     * @param onError
+     *            the action to invoke if the source Observable calls
+     *            onError
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnError()
      * @see MSDN: Observable.Do
@@ -7407,7 +8133,8 @@ public Observable doOnEach(Observer observer) {
     public Observable doOnError(final Action1 onError) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {}
+            public void onCompleted() {
+            }
 
             @Override
             public void onError(Throwable e) {
@@ -7415,22 +8142,23 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(T args) { }
+            public void onNext(T args) {
+            }
 
         };
 
-
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
-    
+
     /**
      * Invokes an action when the source Observable calls
      * onCompleted.
      * 
    
      * 
-     *
-     * @param onCompleted the action to invoke when the source Observable calls
-     *                    onCompleted
+     * 
+     * @param onCompleted
+     *            the action to invoke when the source Observable calls
+     *            onCompleted
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnCompleted()
      * @see MSDN: Observable.Do
@@ -7443,26 +8171,27 @@ public void onCompleted() {
             }
 
             @Override
-            public void onError(Throwable e) { }
+            public void onError(Throwable e) {
+            }
 
             @Override
-            public void onNext(T args) { }
+            public void onNext(T args) {
+            }
 
         };
 
-
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
-    
-    
+
     /**
      * Invokes an action when the source Observable calls
      * onNext.
      * 
    
      * 
-     *
-     * @param onNext the action to invoke when the source Observable calls
-     *               onNext
+     * 
+     * @param onNext
+     *            the action to invoke when the source Observable calls
+     *            onNext
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnNext()
      * @see MSDN: Observable.Do
@@ -7470,13 +8199,15 @@ public void onNext(T args) { }
     public Observable doOnNext(final Action1 onNext) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() { }
+            public void onCompleted() {
+            }
 
             @Override
-            public void onError(Throwable e) { }
+            public void onError(Throwable e) {
+            }
 
             @Override
-            public void onNext(T args) { 
+            public void onNext(T args) {
                 onNext.call(args);
             }
 
@@ -7484,14 +8215,15 @@ public void onNext(T args) {
 
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
-    
+
     /**
      * Invokes an action for each item emitted by the Observable.
      * 
    
      * 
-     *
-     * @param observer the action to invoke for each item emitted by the source
-     *                 Observable
+     * 
+     * @param observer
+     *            the action to invoke for each item emitted by the source
+     *            Observable
      * @return the source Observable with the side-effecting behavior applied
      * @see RxJava Wiki: doOnEach()
      * @see MSDN: Observable.Do
@@ -7560,10 +8292,12 @@ private boolean isInternalImplementation(Object o) {
      * Creates a pattern that matches when both Observables emit an item.
      * 
    
      * 
-     *
-     * @param second Observable to match with the source Observable
+     * 
+     * @param second
+     *            Observable to match with the source Observable
      * @return Pattern object that matches when both Observables emit an item
-     * @throws NullPointerException if right is null
+     * @throws NullPointerException
+     *             if right is null
      * @see RxJava Wiki: and()
      * @see MSDN: Observable.And
      */
@@ -7576,12 +8310,14 @@ public  Pattern2 and(Observable right) {
      * by invoking the selector function.
      * 
    
      * 
-     *
-     * @param selector selector that will be invoked for items emitted by the
-     *                 source Observable
+     * 
+     * @param selector
+     *            selector that will be invoked for items emitted by the
+     *            source Observable
      * @return a Plan that produces the projected results, to be fed (with other
      *         Plans) to the {@link #when} operator
-     * @throws NullPointerException if selector is null
+     * @throws NullPointerException
+     *             if selector is null
      * @see RxJava Wiki: then()
      * @see MSDN: Observable.Then
      */
@@ -7593,12 +8329,13 @@ public  Plan0 then(Func1 selector) {
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param plans a series of plans created by use of the {@link #then}
-     *              operator on patterns
+     * 
+     * @param plans
+     *            a series of plans created by use of the {@link #then} operator on patterns
      * @return an Observable that emits the results from matching several
      *         patterns
-     * @throws NullPointerException if plans is null
+     * @throws NullPointerException
+     *             if plans is null
      * @see RxJava Wiki: when()
      * @see MSDN: Observable.When
      */
@@ -7610,12 +8347,13 @@ public static  Observable when(Plan0... plans) {
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param plans a series of plans created by use of the {@link #then}
-     *              operator on patterns
+     * 
+     * @param plans
+     *            a series of plans created by use of the {@link #then} operator on patterns
      * @return an Observable that emits the results from matching several
      *         patterns
-     * @throws NullPointerException if plans is null
+     * @throws NullPointerException
+     *             if plans is null
      * @see RxJava Wiki: when()
      * @see MSDN: Observable.When
      */
@@ -7630,8 +8368,9 @@ public static  Observable when(Iterable> plans) {
      * Joins the results from a pattern.
      * 
    
      * 
-     *
-     * @param p1 the plan to join
+     * 
+     * @param p1
+     *            the plan to join
      * @return an Observable that emits the results from matching a pattern
      * @see RxJava Wiki: when()
      * @see MSDN: Observable.When
@@ -7645,9 +8384,11 @@ public static  Observable when(Plan0 p1) {
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7662,10 +8403,13 @@ public static  Observable when(Plan0 p1, Plan0 p2) {
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7680,11 +8424,15 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7699,12 +8447,17 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
-     * @param p5 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7719,13 +8472,19 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
-     * @param p5 a plan
-     * @param p6 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7740,14 +8499,21 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
-     * @param p5 a plan
-     * @param p6 a plan
-     * @param p7 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7762,15 +8528,23 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
-     * @param p5 a plan
-     * @param p6 a plan
-     * @param p7 a plan
-     * @param p8 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
+     * @param p8
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7785,16 +8559,25 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * Joins together the results from several patterns.
      * 
    
      * 
-     *
-     * @param p1 a plan
-     * @param p2 a plan
-     * @param p3 a plan
-     * @param p4 a plan
-     * @param p5 a plan
-     * @param p6 a plan
-     * @param p7 a plan
-     * @param p8 a plan
-     * @param p9 a plan
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
+     * @param p8
+     *            a plan
+     * @param p9
+     *            a plan
      * @return an Observable that emits the results from matching several
      *         patterns
      * @see RxJava Wiki: when()
@@ -7810,16 +8593,20 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * durations.
      * 
    
      * 
-     *
-     * @param right the second Observable to join items from
-     * @param leftDurationSelector a function to select the duration of each 
-     *                             item emitted by this Observable, used to
-     *                             determine overlap
-     * @param rightDurationSelector a function to select the duration of each
-     *                              item emitted by the right
-     *                              Observable, used to determine overlap
-     * @param resultSelector a function that computes a result item for any two
-     *                       overlapping items emitted by the two Observables
+     * 
+     * @param right
+     *            the second Observable to join items from
+     * @param leftDurationSelector
+     *            a function to select the duration of each
+     *            item emitted by this Observable, used to
+     *            determine overlap
+     * @param rightDurationSelector
+     *            a function to select the duration of each
+     *            item emitted by the right
+     *            Observable, used to determine overlap
+     * @param resultSelector
+     *            a function that computes a result item for any two
+     *            overlapping items emitted by the two Observables
      * @return an Observable that emits result items computed from source items
      *         that have an overlapping duration
      * @see RxJava Wiki: join()
@@ -7829,20 +8616,20 @@ public  Observable join(Observable<
             Func1> rightDurationSelector,
             Func2 resultSelector) {
         return create(new OperationJoin(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
-    }    
-    
+    }
+
     /**
      * Return an Observable that emits a single HashMap containing all items
-     * emitted by the source Observable, mapped by the keys returned by the
-     * {@code keySelector} function.
+     * emitted by the source Observable, mapped by the keys returned by the {@code keySelector} function.
      * 
    
      * 
      * 
    
      * If a source item maps to the same key, the HashMap will contain the
      * latest of those items.
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as keys in the HashMap
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as keys in the HashMap
      * @return an Observable that emits a single HashMap containing the mapped
      *         items from the source Observable
      * @see RxJava Wiki: toMap()
@@ -7851,7 +8638,7 @@ public  Observable join(Observable<
     public  Observable> toMap(Func1 keySelector) {
         return create(OperationToMap.toMap(this, keySelector));
     }
-    
+
     /**
      * Return an Observable that emits a single HashMap containing elements with
      * key and value extracted from the items emitted by the source Observable.
@@ -7861,10 +8648,12 @@ public  Observable> toMap(Func1 keySelector
      * If a source item maps to the same key, the HashMap will contain the
      * latest of those items.
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the HashMap
-     * @param valueSelector the function that extracts the value from the source
-     *                      items to be used as value in the HashMap
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the HashMap
      * @return an Observable that emits a single HashMap containing the mapped
      *         items from the source Observable
      * @see RxJava Wiki: toMap()
@@ -7873,7 +8662,7 @@ public  Observable> toMap(Func1 keySelector
     public  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
         return create(OperationToMap.toMap(this, keySelector, valueSelector));
     }
-    
+
     /**
      * Return an Observable that emits a single Map, returned by the
      * mapFactory function, containing key and value extracted from
@@ -7881,11 +8670,14 @@ public  Observable> toMap(Func1 keySelec
      * 
    
      * 
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the Map
-     * @param valueSelector the function that extracts the value from the source
-     *                      items to be used as value in the Map
-     * @param mapFactory the function that returns an Map instance to be used
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
      * @return an Observable that emits a single Map containing the mapped
      *         items emitted by the source Observable
      * @see RxJava Wiki: toMap()
@@ -7893,7 +8685,7 @@ public  Observable> toMap(Func1 keySelec
     public  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
         return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
     }
-    
+
     /**
      * Return an Observable that emits a single HashMap containing an ArrayList
      * of items, emitted by the source Observable and keyed by the
@@ -7901,8 +8693,9 @@ public  Observable> toMap(Func1 keySelec
      * 
    
      * 
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the HashMap
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
      * @return an Observable that emits a single HashMap containing an ArrayList
      *         of items mapped from the source Observable
      * @see RxJava Wiki: toMap()
@@ -7911,7 +8704,7 @@ public  Observable> toMap(Func1 keySelec
     public  Observable>> toMultimap(Func1 keySelector) {
         return create(OperationToMultimap.toMultimap(this, keySelector));
     }
-    
+
     /**
      * Return an Observable that emits a single HashMap containing an ArrayList
      * of values, extracted by the valueSelector function, emitted
@@ -7920,10 +8713,12 @@ public  Observable>> toMultimap(Func1
      * 
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the HashMap
-     * @param valueSelector the function that extracts the value from the source
-     *                      items to be used as value in the Map
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
      * @return an Observable that emits a single HashMap containing an ArrayList
      *         of items mapped from the source Observable
      * @see RxJava Wiki: toMap()
@@ -7932,7 +8727,7 @@ public  Observable>> toMultimap(Func1 Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector));
     }
-    
+
     /**
      * Return an Observable that emits a single Map, returned by the
      * mapFactory function, containing an ArrayList of values,
@@ -7941,11 +8736,14 @@ public  Observable>> toMultimap(Func1
      * 
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the Map
-     * @param valueSelector the function that extracts the value from the source
-     *                      items to be used as value in the Map
-     * @param mapFactory the function that returns an Map instance to be used
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
      * @return an Observable that emits a single Map containing the list of
      *         mapped items from the source Observable.
      * @see RxJava Wiki: toMap()
@@ -7962,29 +8760,34 @@ public  Observable>> toMultimap(Func1
      * 
      * 
-     * @param keySelector the function that extracts the key from the source
-     *                    items to be used as key in the Map
-     * @param valueSelector the function that extracts the value from the source
-     *                      items to be used as value in the Map
-     * @param mapFactory the function that returns an Map instance to be used
-     * @param collectionFactory the function that returns a Collection instance
-     *                          for a particular key to be used in the Map
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
+     * @param collectionFactory
+     *            the function that returns a Collection instance
+     *            for a particular key to be used in the Map
      * @return an Observable that emits a single Map containing the collection
      *         of mapped items from the source Observable.
      * @see RxJava Wiki: toMap()
      */
     public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));
-    } 
-    
+    }
+
     /**
      * Return an Observable that skips items from the source Observable until
      * the secondary Observable emits an item.
      * 
    
      * 
      * 
-     * @param other the other Observable that has to emit an item before this
-     *              Observable's elements are relayed
+     * @param other
+     *            the other Observable that has to emit an item before this
+     *            Observable's elements are relayed
      * @return an Observable that skips items from the source Observable
      *         until the secondary Observable emits an item.
      * @see RxJava Wiki: skipUntil()
@@ -7999,9 +8802,11 @@ public  Observable skipUntil(Observable other) {
      * selector function until the duration Observable expires for the key.
      * 
    
      * 
-     *
-     * @param keySelector a function to extract the key for each item
-     * @param durationSelector a function to signal the expiration of a group
+     * 
+     * @param keySelector
+     *            a function to extract the key for each item
+     * @param durationSelector
+     *            a function to signal the expiration of a group
      * @return an Observable that emits grouped Observables, each of which
      *         corresponds to a key value and emits all items that share that
      *         same key value that were emitted during the key's duration
@@ -8009,20 +8814,23 @@ public  Observable skipUntil(Observable other) {
      * @see MSDN: Observable.GroupByUntil
      */
     public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
-        return groupByUntil(keySelector, Functions.identity(), durationSelector);
+        return groupByUntil(keySelector, Functions. identity(), durationSelector);
     }
-    
+
     /**
      * Groups the items emitted by an Observable according to specified key and
      * value selector functions until the duration Observable expires for the
      * key.
      * 
    
      * 
-     *
-     * @param keySelector a function to extract the key for each item
-     * @param valueSelector a function to map each source item to an item
-     *                      emitted by an Observable group
-     * @param durationSelector a function to signal the expiration of a group
+     * 
+     * @param keySelector
+     *            a function to extract the key for each item
+     * @param valueSelector
+     *            a function to map each source item to an item
+     *            emitted by an Observable group
+     * @param durationSelector
+     *            a function to signal the expiration of a group
      * @return an Observable that emits grouped Observables, each of which
      *         corresponds to a key value and emits all items that share that
      *         same key value that were emitted during the key's duration
diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
index fe8ac26e0b..cf87221af0 100644
--- a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
index 2833a2072e..c68d5e7ae8 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
index f3bdf8aa8f..1e1ba108d6 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
index a574442ba6..67d93b2553 100644
--- a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
index cdc9e1f6a3..f64ebd7d26 100644
--- a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
index e402e1b63e..0a40fe7eef 100644
--- a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan0.java b/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
index d8690136b7..d70b0859bf 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
@@ -23,12 +23,13 @@
  */
 public abstract class ActivePlan0 {
     protected final Map joinObservers = new HashMap();
-    
+
     public abstract void match();
-    
+
     protected void addJoinObserver(JoinObserver joinObserver) {
         joinObservers.put(joinObserver, joinObserver);
     }
+
     protected void dequeue() {
         for (JoinObserver jo : joinObservers.values()) {
             jo.dequeue();
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
index d5181b0982..1d192a308b 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -26,6 +26,7 @@ public class ActivePlan1 extends ActivePlan0 {
     private final Action1 onNext;
     private final Action0 onCompleted;
     private final JoinObserver1 first;
+
     public ActivePlan1(JoinObserver1 first, Action1 onNext, Action0 onCompleted) {
         this.onNext = onNext;
         this.onCompleted = onCompleted;
@@ -45,5 +46,5 @@ public void match() {
             }
         }
     }
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
index a91d4fd8f3..c580fd4f76 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -27,6 +27,7 @@ public class ActivePlan2 extends ActivePlan0 {
     private final Action0 onCompleted;
     private final JoinObserver1 first;
     private final JoinObserver1 second;
+
     public ActivePlan2(JoinObserver1 first, JoinObserver1 second, Action2 onNext, Action0 onCompleted) {
         this.onNext = onNext;
         this.onCompleted = onCompleted;
@@ -41,7 +42,7 @@ public void match() {
         if (!first.queue().isEmpty() && !second.queue().isEmpty()) {
             Notification n1 = first.queue().peek();
             Notification n2 = second.queue().peek();
-            
+
             if (n1.isOnCompleted() || n2.isOnCompleted()) {
                 onCompleted.call();
             } else {
@@ -50,5 +51,5 @@ public void match() {
             }
         }
     }
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
index 36bfa0e09e..3930137ac7 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -28,10 +28,11 @@ public class ActivePlan3 extends ActivePlan0 {
     private final JoinObserver1 first;
     private final JoinObserver1 second;
     private final JoinObserver1 third;
-    public ActivePlan3(JoinObserver1 first, 
-            JoinObserver1 second, 
+
+    public ActivePlan3(JoinObserver1 first,
+            JoinObserver1 second,
             JoinObserver1 third,
-            Action3 onNext, 
+            Action3 onNext,
             Action0 onCompleted) {
         this.onNext = onNext;
         this.onCompleted = onCompleted;
@@ -45,13 +46,13 @@ public ActivePlan3(JoinObserver1 first,
 
     @Override
     public void match() {
-        if (!first.queue().isEmpty() 
+        if (!first.queue().isEmpty()
                 && !second.queue().isEmpty()
                 && !third.queue().isEmpty()) {
             Notification n1 = first.queue().peek();
             Notification n2 = second.queue().peek();
             Notification n3 = third.queue().peek();
-            
+
             if (n1.isOnCompleted() || n2.isOnCompleted() || n3.isOnCompleted()) {
                 onCompleted.call();
             } else {
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver.java b/rxjava-core/src/main/java/rx/joins/JoinObserver.java
index 2557427895..68fc3c612e 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -22,5 +22,6 @@
  */
 public interface JoinObserver extends Subscription {
     void subscribe(Object gate);
+
     void dequeue();
 }
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index b191641352..5b5a67eea3 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -41,7 +41,7 @@ public final class JoinObserver1 implements Observer>, JoinOb
     private volatile boolean done;
     private final AtomicBoolean subscribed = new AtomicBoolean(false);
     private final SafeObserver> safeObserver;
-    
+
     public JoinObserver1(Observable source, Action1 onError) {
         this.source = source;
         this.onError = onError;
@@ -49,12 +49,15 @@ public JoinObserver1(Observable source, Action1 onError) {
         activePlans = new ArrayList();
         safeObserver = new SafeObserver>(subscription, new InnerObserver());
     }
+
     public Queue> queue() {
         return queue;
     }
+
     public void addActivePlan(ActivePlan0 activePlan) {
         activePlans.add(activePlan);
     }
+
     @Override
     public void subscribe(Object gate) {
         if (subscribed.compareAndSet(false, true)) {
@@ -100,7 +103,7 @@ public void onCompleted() {
             // not expected or ignored
         }
     }
-    
+
     @Override
     public void onNext(Notification args) {
         safeObserver.onNext(args);
@@ -115,7 +118,7 @@ public void onError(Throwable e) {
     public void onCompleted() {
         safeObserver.onCompleted();
     }
-    
+
     void removeActivePlan(ActivePlan0 activePlan) {
         activePlans.remove(activePlan);
         if (activePlans.isEmpty()) {
@@ -130,5 +133,5 @@ public void unsubscribe() {
             subscription.unsubscribe();
         }
     }
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern.java b/rxjava-core/src/main/java/rx/joins/Pattern.java
index cce00a3af7..d7ec2d07d0 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern.java
@@ -18,8 +18,9 @@
 
 /**
  * Base interface for join patterns.
+ * 
  * @see MSDN: Pattern
  */
 public interface Pattern {
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern1.java b/rxjava-core/src/main/java/rx/joins/Pattern1.java
index 77600647e8..d9f707a951 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern1.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern1.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -23,18 +23,24 @@
  */
 public class Pattern1 implements Pattern {
     private final Observable first;
+
     public Pattern1(Observable first) {
         this.first = first;
     }
+
     public Observable first() {
         return first;
     }
+
     /**
-     * Matches when all observable sequences have an available 
+     * Matches when all observable sequences have an available
      * element and projects the elements by invoking the selector function.
-     * @param selector the function that will be invoked for elements in the source sequences.
-     * @return 
-     * @throws NullPointerException if selector is null
+     * 
+     * @param selector
+     *            the function that will be invoked for elements in the source sequences.
+     * @return
+     * @throws NullPointerException
+     *             if selector is null
      */
     public  Plan0 then(Func1 selector) {
         if (selector == null) {
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern2.java b/rxjava-core/src/main/java/rx/joins/Pattern2.java
index b38ba37253..13c5c6a758 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern2.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern2.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -24,19 +24,25 @@
 public class Pattern2 implements Pattern {
     private final Observable first;
     private final Observable second;
+
     public Pattern2(Observable first, Observable second) {
         this.first = first;
         this.second = second;
     }
+
     public Observable first() {
         return first;
     }
+
     public Observable second() {
         return second;
     }
+
     /**
      * Creates a pattern that matches when all three observable sequences have an available element.
-     * @param other Observable sequence to match with the two previous sequences.
+     * 
+     * @param other
+     *            Observable sequence to match with the two previous sequences.
      * @return Pattern object that matches when all observable sequences have an available element.
      */
     public  Pattern3 and(Observable other) {
@@ -45,6 +51,7 @@ public  Pattern3 and(Observable other) {
         }
         return new Pattern3(first, second, other);
     }
+
     public  Plan0 then(Func2 selector) {
         if (selector == null) {
             throw new NullPointerException();
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern3.java b/rxjava-core/src/main/java/rx/joins/Pattern3.java
index 0871b3d3c2..614748cf2e 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern3.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern3.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -25,31 +25,36 @@ public class Pattern3 implements Pattern {
     private final Observable first;
     private final Observable second;
     private final Observable third;
+
     public Pattern3(Observable first, Observable second,
             Observable third) {
         this.first = first;
         this.second = second;
         this.third = third;
     }
+
     public Observable first() {
         return first;
     }
+
     public Observable second() {
         return second;
     }
+
     public Observable third() {
         return third;
     }
-//    public  Pattern4 and(Observable other) {
-//        if (other == null) {
-//            throw new NullPointerException();
-//        }
-//        return new Pattern4(first, second, third, other);
-//    }
+
+    //    public  Pattern4 and(Observable other) {
+    //        if (other == null) {
+    //            throw new NullPointerException();
+    //        }
+    //        return new Pattern4(first, second, third, other);
+    //    }
     public  Plan0 then(Func3 selector) {
         if (selector == null) {
             throw new NullPointerException();
         }
         return new Plan3(this, selector);
-    }    
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/joins/Plan0.java b/rxjava-core/src/main/java/rx/joins/Plan0.java
index 2a647aff3d..6017c0646e 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan0.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan0.java
@@ -16,6 +16,7 @@
 package rx.joins;
 
 import java.util.Map;
+
 import rx.Observable;
 import rx.Observer;
 import rx.util.functions.Action1;
@@ -24,22 +25,22 @@
  * Represents an execution plan for join patterns.
  */
 public abstract class Plan0 {
-    public abstract ActivePlan0 activate(Map externalSubscriptions, 
+    public abstract ActivePlan0 activate(Map externalSubscriptions,
             Observer observer, Action1 deactivate);
-    
+
     @SuppressWarnings("unchecked")
     public static  JoinObserver1 createObserver(
             Map externalSubscriptions,
             Observable observable,
             Action1 onError
-    ) {
+            ) {
         JoinObserver1 observer;
         JoinObserver nonGeneric = externalSubscriptions.get(observable);
         if (nonGeneric == null) {
             observer = new JoinObserver1(observable, onError);
             externalSubscriptions.put(observable, observer);
         } else {
-            observer = (JoinObserver1)nonGeneric;
+            observer = (JoinObserver1) nonGeneric;
         }
         return observer;
     }
diff --git a/rxjava-core/src/main/java/rx/joins/Plan1.java b/rxjava-core/src/main/java/rx/joins/Plan1.java
index b64742e27b..1487a805fb 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan1.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan1.java
@@ -17,11 +17,12 @@
 
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Observer;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 import rx.util.functions.Actions;
+import rx.util.functions.Func1;
 
 /**
  * Represents an execution plan for join patterns.
@@ -29,15 +30,16 @@
 public class Plan1 extends Plan0 {
     protected Pattern1 expression;
     protected Func1 selector;
-    
+
     public Plan1(Pattern1 expression, Func1 selector) {
         this.expression = expression;
         this.selector = selector;
     }
-    
+
     public Pattern1 expression() {
         return expression;
     }
+
     public Func1 selector() {
         return selector;
     }
@@ -45,11 +47,11 @@ public Func1 selector() {
     @Override
     public ActivePlan0 activate(Map externalSubscriptions, final Observer observer, final Action1 deactivate) {
         Action1 onError = Actions.onErrorFrom(observer);
-        
+
         final JoinObserver1 firstJoinObserver = createObserver(externalSubscriptions, expression.first(), onError);
-        
+
         final AtomicReference> self = new AtomicReference>();
-        
+
         ActivePlan1 activePlan = new ActivePlan1(firstJoinObserver, new Action1() {
             @Override
             public void call(T1 t1) {
@@ -63,18 +65,18 @@ public void call(T1 t1) {
                 observer.onNext(result);
             }
         },
-        new Action0() {
-            @Override
-            public void call() {
-                firstJoinObserver.removeActivePlan(self.get());
-                deactivate.call(self.get());
-            }
-        });
-        
+                new Action0() {
+                    @Override
+                    public void call() {
+                        firstJoinObserver.removeActivePlan(self.get());
+                        deactivate.call(self.get());
+                    }
+                });
+
         self.set(activePlan);
-        
+
         firstJoinObserver.addActivePlan(activePlan);
         return activePlan;
     }
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/Plan2.java b/rxjava-core/src/main/java/rx/joins/Plan2.java
index 456e3c2bb3..a30f341b27 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan2.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan2.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -17,8 +17,8 @@
 
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Observer;
-import static rx.joins.Plan0.createObserver;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
@@ -31,21 +31,22 @@
 public class Plan2 extends Plan0 {
     protected Pattern2 expression;
     protected Func2 selector;
+
     public Plan2(Pattern2 expression, Func2 selector) {
         this.expression = expression;
         this.selector = selector;
     }
 
     @Override
-    public ActivePlan0 activate(Map externalSubscriptions, 
+    public ActivePlan0 activate(Map externalSubscriptions,
             final Observer observer, final Action1 deactivate) {
         Action1 onError = Actions.onErrorFrom(observer);
-        
+
         final JoinObserver1 firstJoinObserver = createObserver(externalSubscriptions, expression.first(), onError);
         final JoinObserver1 secondJoinObserver = createObserver(externalSubscriptions, expression.second(), onError);
-        
+
         final AtomicReference> self = new AtomicReference>();
-        
+
         ActivePlan2 activePlan = new ActivePlan2(firstJoinObserver, secondJoinObserver, new Action2() {
             @Override
             public void call(T1 t1, T2 t2) {
@@ -59,21 +60,21 @@ public void call(T1 t1, T2 t2) {
                 observer.onNext(result);
             }
         },
-        new Action0() {
-            @Override
-            public void call() {
-                firstJoinObserver.removeActivePlan(self.get());
-                secondJoinObserver.removeActivePlan(self.get());
-                deactivate.call(self.get());
-            }
-        });
-        
+                new Action0() {
+                    @Override
+                    public void call() {
+                        firstJoinObserver.removeActivePlan(self.get());
+                        secondJoinObserver.removeActivePlan(self.get());
+                        deactivate.call(self.get());
+                    }
+                });
+
         self.set(activePlan);
-        
+
         firstJoinObserver.addActivePlan(activePlan);
         secondJoinObserver.addActivePlan(activePlan);
-        
+
         return activePlan;
     }
-    
+
 }
diff --git a/rxjava-core/src/main/java/rx/joins/Plan3.java b/rxjava-core/src/main/java/rx/joins/Plan3.java
index 6f12235c51..7b14ddbc9a 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan3.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan3.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -17,8 +17,8 @@
 
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Observer;
-import static rx.joins.Plan0.createObserver;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action3;
@@ -31,52 +31,53 @@
 public class Plan3 extends Plan0 {
     protected Pattern3 expression;
     protected Func3 selector;
+
     public Plan3(Pattern3 expression, Func3 selector) {
         this.expression = expression;
         this.selector = selector;
     }
 
     @Override
-    public ActivePlan0 activate(Map externalSubscriptions, 
+    public ActivePlan0 activate(Map externalSubscriptions,
             final Observer observer, final Action1 deactivate) {
         Action1 onError = Actions.onErrorFrom(observer);
-        
+
         final JoinObserver1 firstJoinObserver = createObserver(externalSubscriptions, expression.first(), onError);
         final JoinObserver1 secondJoinObserver = createObserver(externalSubscriptions, expression.second(), onError);
         final JoinObserver1 thirdJoinObserver = createObserver(externalSubscriptions, expression.third(), onError);
-        
+
         final AtomicReference> self = new AtomicReference>();
-        
-        ActivePlan3 activePlan = new ActivePlan3(firstJoinObserver, secondJoinObserver, 
+
+        ActivePlan3 activePlan = new ActivePlan3(firstJoinObserver, secondJoinObserver,
                 thirdJoinObserver, new Action3() {
-            @Override
-            public void call(T1 t1, T2 t2, T3 t3) {
-                R result;
-                try {
-                    result = selector.call(t1, t2, t3);
-                } catch (Throwable t) {
-                    observer.onError(t);
-                    return;
-                }
-                observer.onNext(result);
-            }
-        },
-        new Action0() {
-            @Override
-            public void call() {
-                firstJoinObserver.removeActivePlan(self.get());
-                secondJoinObserver.removeActivePlan(self.get());
-                thirdJoinObserver.removeActivePlan(self.get());
-                deactivate.call(self.get());
-            }
-        });
-        
+                    @Override
+                    public void call(T1 t1, T2 t2, T3 t3) {
+                        R result;
+                        try {
+                            result = selector.call(t1, t2, t3);
+                        } catch (Throwable t) {
+                            observer.onError(t);
+                            return;
+                        }
+                        observer.onNext(result);
+                    }
+                },
+                new Action0() {
+                    @Override
+                    public void call() {
+                        firstJoinObserver.removeActivePlan(self.get());
+                        secondJoinObserver.removeActivePlan(self.get());
+                        thirdJoinObserver.removeActivePlan(self.get());
+                        deactivate.call(self.get());
+                    }
+                });
+
         self.set(activePlan);
-        
+
         firstJoinObserver.addActivePlan(activePlan);
         secondJoinObserver.addActivePlan(activePlan);
         thirdJoinObserver.addActivePlan(activePlan);
-        
+
         return activePlan;
     }
 
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 87f5fe63b2..262f5f4b80 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -37,9 +37,7 @@
  * An extension of {@link Observable} that provides blocking operators.
  * 
    
  * You construct a BlockingObservable from an
- * Observable with {@link #from(Observable)} or
- * {@link Observable#toBlockingObservable()}
- * 
    
+ * Observable with {@link #from(Observable)} or {@link Observable#toBlockingObservable()} 
    
  * The documentation for this interface makes use of a form of marble diagram
  * that has been modified to illustrate blocking operators. The following legend
  * explains these marble diagrams:
@@ -68,8 +66,7 @@ public static  BlockingObservable from(final Observable o) {
     }
 
     /**
-     * Used for protecting against errors being thrown from {@link Observer}
-     * implementations and ensuring onNext/onError/onCompleted contract
+     * Used for protecting against errors being thrown from {@link Observer} implementations and ensuring onNext/onError/onCompleted contract
      * compliance.
      * 
    
      * See https://github.com/Netflix/RxJava/issues/216 for discussion on
@@ -87,14 +84,14 @@ private Subscription protectivelyWrapAndSubscribe(Observer observer)
      * NOTE: This will block even if the Observable is asynchronous.
      * 
    
      * This is similar to {@link Observable#subscribe(Observer)}, but it blocks.
-     * Because it blocks it does not need the {@link Observer#onCompleted()} or
-     * {@link Observer#onError(Throwable)} methods.
+     * Because it blocks it does not need the {@link Observer#onCompleted()} or {@link Observer#onError(Throwable)} methods.
      * 
    
      * 
      * 
-     * @param onNext the {@link Action1} to invoke for every item emitted by the
-     *               {@link Observable}
-     * @throws RuntimeException if an error occurs
+     * @param onNext
+     *            the {@link Action1} to invoke for every item emitted by the {@link Observable}
+     * @throws RuntimeException
+     *             if an error occurs
      * @see RxJava Wiki: forEach()
      */
     public void forEach(final Action1 onNext) {
@@ -171,7 +168,8 @@ public Iterator getIterator() {
      * IllegalArgumentException if source contains no elements.
      * 
      * @return the first item emitted by the source {@link Observable}
-     * @throws IllegalArgumentException if source contains no elements
+     * @throws IllegalArgumentException
+     *             if source contains no elements
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.First
      */
@@ -184,11 +182,12 @@ public T first() {
      * matches a predicate, or IllegalArgumentException if no such
      * item is emitted.
      * 
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the first item emitted by the {@link Observable} that matches the
      *         predicate
-     * @throws IllegalArgumentException if no such items are emitted
+     * @throws IllegalArgumentException
+     *             if no such items are emitted
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.First
      */
@@ -200,8 +199,8 @@ public T first(Func1 predicate) {
      * Returns the first item emitted by a specified {@link Observable}, or a
      * default value if no items are emitted.
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no items
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no items
      * @return the first item emitted by the {@link Observable}, or the default
      *         value if no items are emitted
      * @see RxJava Wiki: firstOrDefault()
@@ -215,10 +214,10 @@ public T firstOrDefault(T defaultValue) {
      * Returns the first item emitted by a specified {@link Observable} that
      * matches a predicate, or a default value if no such items are emitted.
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no matching items
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no matching items
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the first item emitted by the {@link Observable} that matches the
      *         predicate, or the default value if no matching items are emitted
      * @see RxJava Wiki: firstOrDefault()
@@ -235,7 +234,8 @@ public T firstOrDefault(T defaultValue, Func1 predicate) {
      * 
      * 
      * @return the last item emitted by the source {@link Observable}
-     * @throws IllegalArgumentException if source contains no elements
+     * @throws IllegalArgumentException
+     *             if source contains no elements
      * @see RxJava Wiki: last()
      * @see MSDN: Observable.Last
      */
@@ -250,11 +250,12 @@ public T last() {
      * 
    
      * 
      * 
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the last item emitted by the {@link Observable} that matches the
      *         predicate
-     * @throws IllegalArgumentException if no such items are emitted
+     * @throws IllegalArgumentException
+     *             if no such items are emitted
      * @see RxJava Wiki: last()
      * @see MSDN: Observable.Last
      */
@@ -268,8 +269,8 @@ public T last(final Func1 predicate) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no items
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no items
      * @return the last item emitted by the {@link Observable}, or the default
      *         value if no items are emitted
      * @see RxJava Wiki: lastOrDefault()
@@ -285,10 +286,10 @@ public T lastOrDefault(T defaultValue) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no matching items
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no matching items
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the last item emitted by the {@link Observable} that matches the
      *         predicate, or the default value if no matching items are emitted
      * @see RxJava Wiki: lastOrDefault()
@@ -304,9 +305,8 @@ public T lastOrDefault(T defaultValue, Func1 predicate) {
      * 
    
      * 
      * 
-     * @param initialValue the initial value that will be yielded by the
-     *                     {@link Iterable} sequence if the {@link Observable}
-     *                     has not yet emitted an item
+     * @param initialValue
+     *            the initial value that will be yielded by the {@link Iterable} sequence if the {@link Observable} has not yet emitted an item
      * @return an {@link Iterable} that on each iteration returns the item that
      *         the {@link Observable} has most recently emitted
      * @see RxJava wiki: mostRecent()
@@ -317,8 +317,7 @@ public Iterable mostRecent(T initialValue) {
     }
 
     /**
-     * Returns an {@link Iterable} that blocks until the {@link Observable}
-     * emits another item, then returns that item.
+     * Returns an {@link Iterable} that blocks until the {@link Observable} emits another item, then returns that item.
      * 
    
      * 
      * 
@@ -349,7 +348,7 @@ public Iterable next() {
     public Iterable latest() {
         return OperationLatest.latest(o);
     }
-    
+
     /**
      * If the {@link Observable} completes after emitting a single item, return
      * that item, otherwise throw an IllegalArgumentException.
@@ -371,8 +370,8 @@ public T single() {
      * 
    
      * 
      * 
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the single item emitted by the source {@link Observable} that
      *         matches the predicate
      * @see RxJava Wiki: single()
@@ -390,8 +389,8 @@ public T single(Func1 predicate) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no items
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no items
      * @return the single item emitted by the {@link Observable}, or the default
      *         value if no items are emitted
      * @see RxJava Wiki: singleOrDefault()
@@ -419,10 +418,10 @@ public T singleOrDefault(T defaultValue) {
      * 
    
      * 
      * 
-     * @param defaultValue a default value to return if the {@link Observable}
-     *                     emits no matching items
-     * @param predicate a predicate function to evaluate items emitted by the
-     *                  {@link Observable}
+     * @param defaultValue
+     *            a default value to return if the {@link Observable} emits no matching items
+     * @param predicate
+     *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the single item emitted by the {@link Observable} that matches
      *         the predicate, or the default value if no such items are emitted
      * @see RxJava Wiki: singleOrDefault()
@@ -433,12 +432,10 @@ public T singleOrDefault(T defaultValue, Func1 predicate) {
     }
 
     /**
-     * Returns a {@link Future} representing the single value emitted by an
-     * {@link Observable}.
+     * Returns a {@link Future} representing the single value emitted by an {@link Observable}.
      * 
    
      * toFuture() throws an exception if the Observable emits more
-     * than one item. If the Observable may emit more than item, use
-     * {@link Observable#toList toList()}.toFuture().
+     * than one item. If the Observable may emit more than item, use {@link Observable#toList toList()}.toFuture().
      * 
    
      * 
      * 
@@ -466,4 +463,3 @@ public Iterator iterator() {
         };
     }
 }
-
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 58f908feef..19523ee473 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -207,6 +207,7 @@ public void pushValue(T value) {
                 }
             }
         }
+
         @Override
         public void unsubscribe() {
             for (Subscription s : subscriptions.values()) {
@@ -263,7 +264,7 @@ public void unsubscribe() {
                 s.unsubscribe();
             }
         }
-        
+
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
index e753bb395e..0594c684c9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
@@ -22,7 +22,9 @@
 
 /**
  * Hides the identity of another observable.
- * @param  the return value type of the wrapped observable.
+ * 
+ * @param 
+ *            the return value type of the wrapped observable.
  */
 public final class OperationAsObservable implements OnSubscribeFunc {
     private final Observable source;
@@ -30,6 +32,7 @@ public final class OperationAsObservable implements OnSubscribeFunc {
     public OperationAsObservable(Observable source) {
         this.source = source;
     }
+
     @Override
     public Subscription onSubscribe(Observer t1) {
         return source.subscribe(t1);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
index 29acf784d0..09ce63ecff 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
@@ -105,11 +105,13 @@ public Double call(Tuple2 result) {
             }
         });
     }
-    
+
     /**
      * Compute the average by extracting integer values from the source via an
      * extractor function.
-     * @param  the source value type
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class AverageIntegerExtractor implements OnSubscribeFunc {
         final Observable source;
@@ -124,11 +126,13 @@ public AverageIntegerExtractor(Observable source, Func1 t1) {
             return source.subscribe(new AverageObserver(t1));
         }
+
         /** Computes the average. */
         private final class AverageObserver implements Observer {
             final Observer observer;
             int sum;
             int count;
+
             public AverageObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -158,14 +162,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
-    
+
     /**
      * Compute the average by extracting long values from the source via an
-     * extractor function. 
-     * @param  the source value type
+     * extractor function.
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class AverageLongExtractor implements OnSubscribeFunc {
         final Observable source;
@@ -180,11 +186,13 @@ public AverageLongExtractor(Observable source, Func1 t1) {
             return source.subscribe(new AverageObserver(t1));
         }
+
         /** Computes the average. */
         private final class AverageObserver implements Observer {
             final Observer observer;
             long sum;
             int count;
+
             public AverageObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -214,14 +222,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
-    
+
     /**
      * Compute the average by extracting float values from the source via an
-     * extractor function. 
-     * @param  the source value type
+     * extractor function.
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class AverageFloatExtractor implements OnSubscribeFunc {
         final Observable source;
@@ -236,11 +246,13 @@ public AverageFloatExtractor(Observable source, Func1 t1) {
             return source.subscribe(new AverageObserver(t1));
         }
+
         /** Computes the average. */
         private final class AverageObserver implements Observer {
             final Observer observer;
             float sum;
             int count;
+
             public AverageObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -270,14 +282,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
-    
+
     /**
      * Compute the average by extracting double values from the source via an
-     * extractor function. 
-     * @param  the source value type
+     * extractor function.
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class AverageDoubleExtractor implements OnSubscribeFunc {
         final Observable source;
@@ -292,11 +306,13 @@ public AverageDoubleExtractor(Observable source, Func1 t1) {
             return source.subscribe(new AverageObserver(t1));
         }
+
         /** Computes the average. */
         private final class AverageObserver implements Observer {
             final Observer observer;
             double sum;
             int count;
+
             public AverageObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -326,7 +342,7 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index 4259bf8910..811676bd71 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -43,7 +43,7 @@ public Buffer call() {
 
     /**
      * 
    This method creates a {@link Func1} object which represents the buffer operation. This operation takes
-     * values from the specified {@link Observable} source and stores them in a buffer until the {@link Observable} constructed using the {@link Func0} argument, produces a 
+     * values from the specified {@link Observable} source and stores them in a buffer until the {@link Observable} constructed using the {@link Func0} argument, produces a
      * value. The buffer is then
      * emitted, and a new buffer is created to replace it. A new {@link Observable} will be constructed using the
      * provided {@link Func0} object, which will determine when this new buffer is emitted. When the source {@link Observable} completes or produces an error, the current buffer is emitted, and the
@@ -70,12 +70,11 @@ public Subscription onSubscribe(Observer> observer) {
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator, TClosing>(buffers, bufferClosingSelector);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(buffers, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(buffers, observer, creator)));
             }
         };
     }
-    
+
     /**
      * 
    This method creates a {@link Func1} object which represents the buffer operation. This operation takes
      * values from the specified {@link Observable} source and stores them in the currently active chunks. Initially
@@ -109,8 +108,7 @@ public Subscription onSubscribe(final Observer> observer) {
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator, TOpening, TClosing>(buffers, bufferOpenings, bufferClosingSelector);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(buffers, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(buffers, observer, creator)));
             }
         };
     }
@@ -167,8 +165,7 @@ public Subscription onSubscribe(final Observer> observer) {
                 ChunkCreator creator = new SkippingChunkCreator>(chunks, skip);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(chunks, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(chunks, observer, creator)));
             }
         };
     }
@@ -225,8 +222,7 @@ public Subscription onSubscribe(final Observer> observer) {
                 ChunkCreator creator = new TimeBasedChunkCreator>(buffers, timespan, unit, scheduler);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(buffers, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(buffers, observer, creator)));
             }
         };
     }
@@ -290,8 +286,7 @@ public Subscription onSubscribe(final Observer> observer) {
                 return new CompositeSubscription(
                         chunks,
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(chunks, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(chunks, observer, creator)));
             }
         };
     }
@@ -355,8 +350,7 @@ public Subscription onSubscribe(final Observer> observer) {
                 return new CompositeSubscription(
                         buffers,
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver>(buffers, observer, creator))
-                );
+                        source.subscribe(new ChunkObserver>(buffers, observer, creator)));
             }
         };
     }
@@ -378,17 +372,19 @@ public List getContents() {
             return contents;
         }
     }
-    
+
     /**
      * Converts a chunk creator into a subscription which stops the chunk.
      */
     private static class ChunkToSubscription implements Subscription {
         private ChunkCreator cc;
         private final AtomicBoolean done;
+
         public ChunkToSubscription(ChunkCreator cc) {
             this.cc = cc;
             this.done = new AtomicBoolean();
         }
+
         @Override
         public void unsubscribe() {
             if (done.compareAndSet(false, true)) {
@@ -398,13 +394,14 @@ public void unsubscribe() {
             }
         }
     }
-    
+
     /**
      * Create a buffer operator with the given observable sequence as the buffer boundary.
      */
     public static  OnSubscribeFunc> bufferWithBoundaryObservable(Observable source, Observable boundary) {
         return new BufferWithObservableBoundary(source, boundary, 16);
     }
+
     /**
      * Create a buffer operator with the given observable sequence as the buffer boundary and
      * with the given initial capacity for buffers.
@@ -415,10 +412,12 @@ public static  OnSubscribeFunc> bufferWithBoundaryObservable(Obser
         }
         return new BufferWithObservableBoundary(source, boundary, initialCapacity);
     }
-    
+
     /**
      * Buffer until an element is emitted from a helper observable.
-     * @param  the buffered value type
+     * 
+     * @param 
+     *            the buffered value type
      */
     private static final class BufferWithObservableBoundary implements OnSubscribeFunc> {
         final Observable source;
@@ -434,13 +433,14 @@ public BufferWithObservableBoundary(Observable source, Observable> t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             SourceObserver so = new SourceObserver(t1, initialCapacity, csub);
             csub.add(source.subscribe(so));
             csub.add(boundary.subscribe(new BoundaryObserver(so)));
-            
+
             return csub;
         }
+
         /**
          * Observes the source.
          */
@@ -451,6 +451,7 @@ private static final class SourceObserver implements Observer {
             final int initialCapacity;
             final Object guard;
             final Subscription cancel;
+
             public SourceObserver(Observer> observer, int initialCapacity, Subscription cancel) {
                 this.observer = observer;
                 this.initialCapacity = initialCapacity;
@@ -483,6 +484,7 @@ public void onCompleted() {
                 emitAndComplete();
                 cancel.unsubscribe();
             }
+
             void emitAndReplace() {
                 List buf;
                 synchronized (guard) {
@@ -494,6 +496,7 @@ void emitAndReplace() {
                 }
                 observer.onNext(buf);
             }
+
             void emitAndComplete() {
                 List buf;
                 synchronized (guard) {
@@ -507,6 +510,7 @@ void emitAndComplete() {
                 observer.onCompleted();
             }
         }
+
         /**
          * Observes the boundary.
          */
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCast.java b/rxjava-core/src/main/java/rx/operators/OperationCast.java
index dc54c204f6..7b1a21cbda 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCast.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
index e2c9be1ebf..ed99ea2b2b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
@@ -55,7 +55,7 @@ public static  OnSubscribeFunc concat(final Observable t1) {
                 return new Concat(sequences).onSubscribe(t1);
-            }            
+            }
         };
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 99d3a47a38..3201eaaf97 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -153,7 +153,7 @@ public void call() {
             }
         }
     }
-    
+
     /**
      * Delay the emission via another observable if no new source appears in the meantime.
      */
@@ -162,7 +162,7 @@ public static  OnSubscribeFunc debounceSelector(
             Func1> debounceSelector) {
         return new DebounceSelector(source, debounceSelector);
     }
-    
+
     /**
      * Delay the emission via another observable if no new source appears in the meantime.
      */
@@ -178,12 +178,12 @@ public DebounceSelector(Observable source, Func1 t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             csub.add(source.subscribe(new SourceObserver(t1, debounceSelector, csub)));
-            
+
             return csub;
         }
-        
+
         /** Observe the source. */
         private static final class SourceObserver implements Observer {
             final Observer observer;
@@ -194,10 +194,10 @@ private static final class SourceObserver implements Observer {
             T value;
             boolean hasValue;
             final Object guard;
-            
+
             public SourceObserver(
-                    Observer observer, 
-                    Func1> debounceSelector, 
+                    Observer observer,
+                    Func1> debounceSelector,
                     CompositeSubscription cancel) {
                 this.observer = observer;
                 this.debounceSelector = debounceSelector;
@@ -224,7 +224,7 @@ public void onNext(T args) {
                     value = args;
                     currentIndex = ++index;
                 }
-                
+
                 SerialSubscription osub = new SerialSubscription();
                 ssub.set(osub);
 
@@ -269,6 +269,7 @@ public void onCompleted() {
                 }
             }
         }
+
         /**
          * The debounce observer.
          */
@@ -308,7 +309,7 @@ public void onCompleted() {
                 }
                 cancel.unsubscribe();
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
index 7bc74ac156..3bd2a316b9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index e553d09b60..7df55048fe 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -48,14 +48,14 @@ public T call(Long ignored) {
         });
         return Observable.concat(seqs);
     }
-    
+
     /**
      * Delays the subscription to the source by the given amount, running on the given scheduler.
      */
     public static  OnSubscribeFunc delaySubscription(Observable source, long time, TimeUnit unit, Scheduler scheduler) {
         return new DelaySubscribeFunc(source, time, unit, scheduler);
     }
-    
+
     /** Subscribe function which schedules the actual subscription to source on a scheduler at a later time. */
     private static final class DelaySubscribeFunc implements OnSubscribeFunc {
         final Observable source;
@@ -69,10 +69,11 @@ public DelaySubscribeFunc(Observable source, long time, TimeUnit un
             this.time = time;
             this.unit = unit;
         }
+
         @Override
         public Subscription onSubscribe(final Observer t1) {
             final SerialSubscription ssub = new SerialSubscription();
-            
+
             ssub.setSubscription(scheduler.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -81,25 +82,28 @@ public void call() {
                     }
                 }
             }, time, unit));
-            
+
             return ssub;
         }
     }
+
     /**
      * Delay the emission of the source items by a per-item observable that fires its first element.
      */
-    public static  OnSubscribeFunc delay(Observable source, 
+    public static  OnSubscribeFunc delay(Observable source,
             Func1> itemDelay) {
         return new DelayViaObservable(source, null, itemDelay);
     }
+
     /**
      * Delay the subscription and emission of the source items by a per-item observable that fires its first element.
      */
-    public static  OnSubscribeFunc delay(Observable source, 
+    public static  OnSubscribeFunc delay(Observable source,
             Func0> subscriptionDelay,
             Func1> itemDelay) {
         return new DelayViaObservable(source, subscriptionDelay, itemDelay);
     }
+
     /**
      * Delay the emission of the source items by a per-item observable that fires its first element.
      */
@@ -108,7 +112,7 @@ private static final class DelayViaObservable implements OnSubscribeFun
         final Func0> subscriptionDelay;
         final Func1> itemDelay;
 
-        public DelayViaObservable(Observable source, 
+        public DelayViaObservable(Observable source,
                 Func0> subscriptionDelay,
                 Func1> itemDelay) {
             this.source = source;
@@ -119,7 +123,7 @@ public DelayViaObservable(Observable source,
         @Override
         public Subscription onSubscribe(Observer t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             SerialSubscription sosub = new SerialSubscription();
             csub.add(sosub);
             SourceObserver so = new SourceObserver(t1, itemDelay, csub, sosub);
@@ -137,9 +141,10 @@ public Subscription onSubscribe(Observer t1) {
                 csub.add(ssub);
                 ssub.set(subscriptionSource.subscribe(new SubscribeDelay(source, so, csub, ssub)));
             }
-            
+
             return csub;
         }
+
         /** Subscribe delay observer. */
         private static final class SubscribeDelay implements Observer {
             final Observable source;
@@ -151,7 +156,7 @@ private static final class SubscribeDelay implements Observer {
 
             public SubscribeDelay(
                     Observable source,
-                    SourceObserver so, 
+                    SourceObserver so,
                     CompositeSubscription csub, Subscription self) {
                 this.source = source;
                 this.so = so;
@@ -179,6 +184,7 @@ public void onCompleted() {
                 so.self.set(source.subscribe(so));
             }
         }
+
         /** The source observer. */
         private static final class SourceObserver implements Observer {
             final Observer observer;
@@ -190,8 +196,8 @@ private static final class SourceObserver implements Observer {
             boolean done;
             int wip;
 
-            public SourceObserver(Observer observer, 
-                    Func1> itemDelay, 
+            public SourceObserver(Observer observer,
+                    Func1> itemDelay,
                     CompositeSubscription csub,
                     SerialSubscription self) {
                 this.observer = observer;
@@ -210,11 +216,11 @@ public void onNext(T args) {
                     onError(t);
                     return;
                 }
-                
+
                 synchronized (guard) {
                     wip++;
                 }
-                
+
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
                 ssub.set(delayer.subscribe(new DelayObserver(args, this, ssub)));
@@ -241,7 +247,7 @@ public void onCompleted() {
                     self.unsubscribe();
                 }
             }
-            
+
             void emit(T value, Subscription token) {
                 boolean b;
                 synchronized (guard) {
@@ -255,6 +261,7 @@ void emit(T value, Subscription token) {
                     csub.remove(token);
                 }
             }
+
             boolean checkDone() {
                 if (done && wip == 0) {
                     observer.onCompleted();
@@ -263,6 +270,7 @@ boolean checkDone() {
                 return false;
             }
         }
+
         /**
          * Delay observer.
          */
@@ -291,7 +299,7 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 parent.emit(value, token);
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
index 871238a0b0..7bdf886976 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
index a1a39f5b2b..c94025dcaf 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import java.util.concurrent.atomic.AtomicInteger;
+
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
@@ -31,8 +32,10 @@
  */
 public final class OperationFlatMap {
     /** Utility class. */
-    private OperationFlatMap() { throw new IllegalStateException("No instances!"); }
-    
+    private OperationFlatMap() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Observable that pairs up the source values and all the derived collection
      * values and projects them via the selector.
@@ -43,6 +46,7 @@ public static  OnSubscribeFunc flatMap(Observable sourc
             ) {
         return new FlatMapPairSelector(source, collectionSelector, resultSelector);
     }
+
     /**
      * Converts the result Iterable of a function into an Observable.
      */
@@ -50,10 +54,14 @@ public static  Func1> flatMapIterableFunc(
             Func1> collectionSelector) {
         return new IterableToObservableFunc(collectionSelector);
     }
+
     /**
      * Converts the result Iterable of a function into an Observable.
-     * @param  the parameter type
-     * @param  the result type
+     * 
+     * @param 
+     *            the parameter type
+     * @param 
+     *            the result type
      */
     private static final class IterableToObservableFunc implements Func1> {
         final Func1> func;
@@ -67,12 +75,17 @@ public Observable call(T t1) {
             return Observable.from(func.call(t1));
         }
     }
+
     /**
      * Pairs up the source value with each of the associated observable values
      * and uses a selector function to calculate the result sequence.
-     * @param  the source value type
-     * @param  the collection value type
-     * @param  the result type
+     * 
+     * @param 
+     *            the source value type
+     * @param 
+     *            the collection value type
+     * @param 
+     *            the result type
      */
     private static final class FlatMapPairSelector implements OnSubscribeFunc {
         final Observable source;
@@ -88,12 +101,12 @@ public FlatMapPairSelector(Observable source, Func1 t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             csub.add(source.subscribe(new SourceObserver(t1, collectionSelector, resultSelector, csub)));
-            
+
             return csub;
         }
-        
+
         /** Observes the source, starts the collections and projects the result. */
         private static final class SourceObserver implements Observer {
             final Observer observer;
@@ -123,11 +136,11 @@ public void onNext(T args) {
                     onError(e);
                     return;
                 }
-                
+
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
                 wip.incrementAndGet();
-                
+
                 ssub.set(coll.subscribe(new CollectionObserver(this, args, ssub)));
             }
 
@@ -156,12 +169,12 @@ public void onCompleted() {
                     csub.unsubscribe();
                 }
             }
-            
+
             void complete(Subscription s) {
                 csub.remove(s);
                 onCompleted();
             }
-            
+
             void emit(T t, U u) {
                 R r;
                 try {
@@ -178,6 +191,7 @@ void emit(T t, U u) {
                 }
             }
         }
+
         /** Observe a collection and call emit with the pair of the key and the value. */
         private static final class CollectionObserver implements Observer {
             final SourceObserver so;
@@ -206,23 +220,26 @@ public void onCompleted() {
             }
         };
     }
-    
+
     /**
      * Projects the notification of an observable sequence to an observable
      * sequence and merges the results into one.
      */
-    public static  OnSubscribeFunc flatMap(Observable source, 
-            Func1> onNext, 
-            Func1> onError, 
+    public static  OnSubscribeFunc flatMap(Observable source,
+            Func1> onNext,
+            Func1> onError,
             Func0> onCompleted) {
         return new FlatMapTransform(source, onNext, onError, onCompleted);
     }
-    
+
     /**
      * Projects the notification of an observable sequence to an observable
      * sequence and merges the results into one.
-     * @param  the source value type
-     * @param  the result value type
+     * 
+     * @param 
+     *            the source value type
+     * @param 
+     *            the result value type
      */
     private static final class FlatMapTransform implements OnSubscribeFunc {
         final Observable source;
@@ -240,15 +257,19 @@ public FlatMapTransform(Observable source, Func1 t1) {
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             csub.add(source.subscribe(new SourceObserver(t1, onNext, onError, onCompleted, csub)));
-            
+
             return csub;
         }
+
         /**
          * Observe the source and merge the values.
-         * @param  the source value type
-         * @param  the result value type
+         * 
+         * @param 
+         *            the source value type
+         * @param 
+         *            the result value type
          */
         private static final class SourceObserver implements Observer {
             final Observer observer;
@@ -318,14 +339,15 @@ public void onCompleted() {
                 done = true;
                 finish();
             }
-            
+
             void subscribeInner(Observable o) {
                 SerialSubscription ssub = new SerialSubscription();
                 wip.incrementAndGet();
                 csub.add(ssub);
-                
+
                 ssub.set(o.subscribe(new CollectionObserver(this, ssub)));
             }
+
             void finish() {
                 if (wip.decrementAndGet() == 0) {
                     synchronized (guard) {
@@ -335,6 +357,7 @@ void finish() {
                 }
             }
         }
+
         /** Observes the collections. */
         private static final class CollectionObserver implements Observer {
             final SourceObserver parent;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index d4f1406c9b..d18d742b23 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -1,18 +1,18 @@
- /**
-  * 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.
-  */
+/**
+ * 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 java.util.ArrayList;
@@ -34,7 +34,7 @@
 
 /**
  * Groups the elements of an observable sequence according to a specified key selector, value selector and duration selector function.
- *
+ * 
  * @see MSDN: Observable.GroupByUntil
  * @see MSDN: Observable.GroupByUntil
  */
@@ -43,6 +43,7 @@ public class OperationGroupByUntil implements
     final Func1 keySelector;
     final Func1 valueSelector;
     final Func1, ? extends Observable> durationSelector;
+
     public OperationGroupByUntil(Observable source,
             Func1 keySelector,
             Func1 valueSelector,
@@ -52,7 +53,7 @@ public OperationGroupByUntil(Observable source,
         this.valueSelector = valueSelector;
         this.durationSelector = durationSelector;
     }
-    
+
     @Override
     public Subscription onSubscribe(Observer> t1) {
         SerialSubscription cancel = new SerialSubscription();
@@ -60,6 +61,7 @@ public Subscription onSubscribe(Observer {
         /** Guarded by gate. */
@@ -69,20 +71,22 @@ class ResultSink implements Observer {
         protected final Object gate = new Object();
         /** Guarded by gate. */
         protected final Map> map = new HashMap>();
+
         public ResultSink(Observer> observer, Subscription cancel) {
             this.observer = observer;
             this.cancel = cancel;
         }
+
         /** Prepare the subscription tree. */
         public Subscription run() {
             SerialSubscription toSource = new SerialSubscription();
             group.add(toSource);
-            
+
             toSource.setSubscription(source.subscribe(this));
-            
+
             return group;
         }
-        
+
         @Override
         public void onNext(TSource args) {
             TKey key;
@@ -94,7 +98,7 @@ public void onNext(TSource args) {
                 onError(t);
                 return;
             }
-            
+
             GroupSubject g;
             boolean newGroup = false;
             synchronized (key) {
@@ -105,7 +109,7 @@ public void onNext(TSource args) {
                     newGroup = true;
                 }
             }
-            
+
             if (newGroup) {
                 Observable duration;
                 try {
@@ -114,24 +118,24 @@ public void onNext(TSource args) {
                     onError(t);
                     return;
                 }
-                
+
                 synchronized (gate) {
                     observer.onNext(g);
                 }
-                
+
                 SerialSubscription durationHandle = new SerialSubscription();
                 group.add(durationHandle);
-                
+
                 DurationObserver durationObserver = new DurationObserver(key, durationHandle);
                 durationHandle.setSubscription(duration.subscribe(durationObserver));
-                
+
             }
-            
+
             synchronized (gate) {
                 g.onNext(value);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             synchronized (gate) {
@@ -144,7 +148,7 @@ public void onError(Throwable e) {
             }
             cancel.unsubscribe();
         }
-        
+
         @Override
         public void onCompleted() {
             synchronized (gate) {
@@ -157,11 +161,13 @@ public void onCompleted() {
             }
             cancel.unsubscribe();
         }
+
         /** Create a new group. */
         public GroupSubject create(TKey key) {
             PublishSubject publish = PublishSubject.create();
             return new GroupSubject(key, publish);
         }
+
         /** Terminate a group. */
         public void expire(TKey key, Subscription handle) {
             synchronized (gate) {
@@ -172,31 +178,35 @@ public void expire(TKey key, Subscription handle) {
             }
             handle.unsubscribe();
         }
+
         /** Observe the completion of a group. */
         class DurationObserver implements Observer {
             final TKey key;
             final Subscription handle;
+
             public DurationObserver(TKey key, Subscription handle) {
                 this.key = key;
                 this.handle = handle;
             }
+
             @Override
             public void onNext(TDuration args) {
                 expire(key, handle);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 ResultSink.this.onError(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 expire(key, handle);
             }
-            
+
         }
     }
+
     protected static  OnSubscribeFunc neverSubscribe() {
         return new OnSubscribeFunc() {
             @Override
@@ -205,33 +215,35 @@ public Subscription onSubscribe(Observer t1) {
             }
         };
     }
+
     /** A grouped observable with subject-like behavior. */
     public static class GroupSubject extends GroupedObservable implements Observer {
         protected final Subject publish;
+
         public GroupSubject(K key, Subject publish) {
-            super(key, OperationGroupByUntil.neverSubscribe());
+            super(key, OperationGroupByUntil. neverSubscribe());
             this.publish = publish;
         }
-        
+
         @Override
         public Subscription subscribe(Observer observer) {
             return publish.subscribe(observer);
         }
-        
+
         @Override
         public void onNext(V args) {
             publish.onNext(args);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             publish.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             publish.onCompleted();
         }
-        
+
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
index 56d009db0a..68d60f3a35 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
@@ -43,25 +43,27 @@ public class OperationGroupJoin implements OnSubscribeFunc
     protected final Func1> leftDuration;
     protected final Func1> rightDuration;
     protected final Func2, ? extends R> resultSelector;
+
     public OperationGroupJoin(
-        Observable left,
-        Observable right,
-        Func1> leftDuration,
-        Func1> rightDuration,
-        Func2, ? extends R> resultSelector
-    ) {
+            Observable left,
+            Observable right,
+            Func1> leftDuration,
+            Func1> rightDuration,
+            Func2, ? extends R> resultSelector) {
         this.left = left;
         this.right = right;
         this.leftDuration = leftDuration;
         this.rightDuration = rightDuration;
         this.resultSelector = resultSelector;
     }
+
     @Override
     public Subscription onSubscribe(Observer t1) {
         ResultManager ro = new ResultManager(t1);
         ro.init();
         return ro;
     }
+
     /** Manages sub-observers and subscriptions. */
     class ResultManager implements Subscription {
         final RefCountSubscription cancel;
@@ -74,27 +76,30 @@ class ResultManager implements Subscription {
         final Map rightMap = new HashMap();
         boolean leftDone;
         boolean rightDone;
+
         public ResultManager(Observer observer) {
             this.observer = observer;
             this.group = new CompositeSubscription();
             this.cancel = new RefCountSubscription(group);
         }
+
         public void init() {
             SerialSubscription s1 = new SerialSubscription();
             SerialSubscription s2 = new SerialSubscription();
-            
+
             group.add(s1);
             group.add(s2);
-            
+
             s1.setSubscription(left.subscribe(new LeftObserver(s1)));
             s2.setSubscription(right.subscribe(new RightObserver(s2)));
-            
+
         }
 
         @Override
         public void unsubscribe() {
             cancel.unsubscribe();
         }
+
         void groupsOnCompleted() {
             List> list = new ArrayList>(leftMap.values());
             leftMap.clear();
@@ -103,12 +108,15 @@ void groupsOnCompleted() {
                 o.onCompleted();
             }
         }
+
         /** Observe the left source. */
         class LeftObserver implements Observer {
             final Subscription tosource;
+
             public LeftObserver(Subscription tosource) {
                 this.tosource = tosource;
             }
+
             @Override
             public void onNext(T1 args) {
                 try {
@@ -118,9 +126,9 @@ public void onNext(T1 args) {
                         id = leftIds++;
                         leftMap.put(id, subj);
                     }
-                    
+
                     Observable window = Observable.create(new WindowObservableFunc(subj, cancel));
-                    
+
                     Observable duration = leftDuration.call(args);
 
                     SerialSubscription sduration = new SerialSubscription();
@@ -128,7 +136,7 @@ public void onNext(T1 args) {
                     sduration.setSubscription(duration.subscribe(new LeftDurationObserver(id, sduration, subj)));
 
                     R result = resultSelector.call(args, window);
-                    
+
                     synchronized (guard) {
                         observer.onNext(result);
                         for (T2 t2 : rightMap.values()) {
@@ -164,14 +172,16 @@ public void onError(Throwable e) {
                 }
             }
 
-            
         }
+
         /** Observe the right source. */
         class RightObserver implements Observer {
             final Subscription tosource;
+
             public RightObserver(Subscription tosource) {
                 this.tosource = tosource;
             }
+
             @Override
             public void onNext(T2 args) {
                 try {
@@ -195,10 +205,10 @@ public void onNext(T2 args) {
                     onError(t);
                 }
             }
-            
+
             @Override
             public void onCompleted() {
-//                tosource.unsubscribe();
+                //                tosource.unsubscribe();
                 synchronized (guard) {
                     rightDone = true;
                     if (leftDone) {
@@ -215,17 +225,19 @@ public void onError(Throwable e) {
                     for (Observer o : leftMap.values()) {
                         o.onError(e);
                     }
-                            
+
                     observer.onError(e);
                     cancel.unsubscribe();
                 }
-            }        
+            }
         }
+
         /** Observe left duration and apply termination. */
         class LeftDurationObserver implements Observer {
             final int id;
             final Subscription sduration;
             final Observer gr;
+
             public LeftDurationObserver(int id, Subscription sduration, Observer gr) {
                 this.id = id;
                 this.sduration = sduration;
@@ -255,10 +267,12 @@ public void onNext(D1 args) {
                 onCompleted();
             }
         }
+
         /** Observe right duration and apply termination. */
         class RightDurationObserver implements Observer {
             final int id;
             final Subscription sduration;
+
             public RightDurationObserver(int id, Subscription sduration) {
                 this.id = id;
                 this.sduration = sduration;
@@ -286,14 +300,16 @@ public void onNext(D2 args) {
             }
         }
     }
-    /** 
-     * The reference-counted window observable. 
+
+    /**
+     * The reference-counted window observable.
      * Subscribes to the underlying Observable by using a reference-counted
      * subscription.
      */
     static class WindowObservableFunc implements OnSubscribeFunc {
         final RefCountSubscription refCount;
         final Observable underlying;
+
         public WindowObservableFunc(Observable underlying, RefCountSubscription refCount) {
             this.refCount = refCount;
             this.underlying = underlying;
@@ -307,23 +323,28 @@ public Subscription onSubscribe(Observer t1) {
             cs.add(underlying.subscribe(wo));
             return cs;
         }
+
         /** Observe activities on the window. */
         class WindowObserver implements Observer {
             final Observer observer;
             final Subscription self;
+
             public WindowObserver(Observer observer, Subscription self) {
                 this.observer = observer;
                 this.self = self;
             }
+
             @Override
             public void onNext(T args) {
                 observer.onNext(args);
             }
+
             @Override
             public void onError(Throwable e) {
                 observer.onError(e);
                 self.unsubscribe();
             }
+
             @Override
             public void onCompleted() {
                 observer.onCompleted();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index f75bf10930..8c20a6e0d0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -36,8 +36,9 @@ public class OperationJoin impl
     final Func1> leftDurationSelector;
     final Func1> rightDurationSelector;
     final Func2 resultSelector;
+
     public OperationJoin(
-            Observable left, 
+            Observable left,
             Observable right,
             Func1> leftDurationSelector,
             Func1> rightDurationSelector,
@@ -56,6 +57,7 @@ public Subscription onSubscribe(Observer t1) {
         cancel.setSubscription(result.run());
         return cancel;
     }
+
     /** Manage the left and right sources. */
     class ResultSink {
         final Object gate = new Object();
@@ -68,28 +70,33 @@ class ResultSink {
         final Map rightMap = new HashMap();
         final Observer observer;
         final Subscription cancel;
+
         public ResultSink(Observer observer, Subscription cancel) {
             this.observer = observer;
             this.cancel = cancel;
         }
+
         public Subscription run() {
             SerialSubscription leftCancel = new SerialSubscription();
             SerialSubscription rightCancel = new SerialSubscription();
-            
+
             group.add(leftCancel);
             group.add(rightCancel);
-            
+
             leftCancel.setSubscription(left.subscribe(new LeftObserver(leftCancel)));
             rightCancel.setSubscription(right.subscribe(new RightObserver(rightCancel)));
-            
+
             return group;
         }
+
         /** Observes the left values. */
         class LeftObserver implements Observer {
             final Subscription self;
+
             public LeftObserver(Subscription self) {
                 this.self = self;
             }
+
             protected void expire(int id, Subscription resource) {
                 synchronized (gate) {
                     if (leftMap.remove(id) != null && leftMap.isEmpty() && leftDone) {
@@ -99,6 +106,7 @@ protected void expire(int id, Subscription resource) {
                 }
                 group.remove(resource);
             }
+
             @Override
             public void onNext(TLeft args) {
                 int id;
@@ -108,7 +116,7 @@ public void onNext(TLeft args) {
                 }
                 SerialSubscription md = new SerialSubscription();
                 group.add(md);
-                
+
                 Observable duration;
                 try {
                     duration = leftDurationSelector.call(args);
@@ -117,9 +125,9 @@ public void onNext(TLeft args) {
                     cancel.unsubscribe();
                     return;
                 }
-                
+
                 md.setSubscription(duration.subscribe(new LeftDurationObserver(id, md)));
-                
+
                 synchronized (gate) {
                     for (TRight r : rightMap.values()) {
                         R result;
@@ -134,6 +142,7 @@ public void onNext(TLeft args) {
                     }
                 }
             }
+
             @Override
             public void onError(Throwable e) {
                 synchronized (gate) {
@@ -141,6 +150,7 @@ public void onError(Throwable e) {
                     cancel.unsubscribe();
                 }
             }
+
             @Override
             public void onCompleted() {
                 synchronized (gate) {
@@ -153,10 +163,12 @@ public void onCompleted() {
                     }
                 }
             }
+
             /** Observes the left duration. */
             class LeftDurationObserver implements Observer {
                 final int id;
                 final Subscription handle;
+
                 public LeftDurationObserver(int id, Subscription handle) {
                     this.id = id;
                     this.handle = handle;
@@ -176,15 +188,18 @@ public void onError(Throwable e) {
                 public void onCompleted() {
                     expire(id, handle);
                 }
-                
+
             }
         }
+
         /** Observes the right values. */
         class RightObserver implements Observer {
             final Subscription self;
+
             public RightObserver(Subscription self) {
                 this.self = self;
             }
+
             void expire(int id, Subscription resource) {
                 synchronized (gate) {
                     if (rightMap.remove(id) != null && rightMap.isEmpty() && rightDone) {
@@ -194,6 +209,7 @@ void expire(int id, Subscription resource) {
                 }
                 group.remove(resource);
             }
+
             @Override
             public void onNext(TRight args) {
                 int id = 0;
@@ -203,7 +219,7 @@ public void onNext(TRight args) {
                 }
                 SerialSubscription md = new SerialSubscription();
                 group.add(md);
-                
+
                 Observable duration;
                 try {
                     duration = rightDurationSelector.call(args);
@@ -212,9 +228,9 @@ public void onNext(TRight args) {
                     cancel.unsubscribe();
                     return;
                 }
-                
+
                 md.setSubscription(duration.subscribe(new RightDurationObserver(id, md)));
-                
+
                 synchronized (gate) {
                     for (TLeft lv : leftMap.values()) {
                         R result;
@@ -229,6 +245,7 @@ public void onNext(TRight args) {
                     }
                 }
             }
+
             @Override
             public void onError(Throwable e) {
                 synchronized (gate) {
@@ -236,6 +253,7 @@ public void onError(Throwable e) {
                     cancel.unsubscribe();
                 }
             }
+
             @Override
             public void onCompleted() {
                 synchronized (gate) {
@@ -248,10 +266,12 @@ public void onCompleted() {
                     }
                 }
             }
+
             /** Observe the right duration. */
             class RightDurationObserver implements Observer {
                 final int id;
                 final Subscription handle;
+
                 public RightDurationObserver(int id, Subscription handle) {
                     this.id = id;
                     this.handle = handle;
@@ -271,7 +291,7 @@ public void onError(Throwable e) {
                 public void onCompleted() {
                     expire(id, handle);
                 }
-                
+
             }
         }
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
index be3c5375cf..2855318554 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
@@ -1,18 +1,18 @@
- /**
-  * 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.
-  */
+/**
+ * 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 java.util.ArrayList;
@@ -50,6 +50,7 @@ public static  Pattern2 and(/* this */Observable left, Obser
         }
         return new Pattern2(left, right);
     }
+
     /**
      * Matches when the observable sequence has an available element and projects the element by invoking the selector function.
      */
@@ -62,6 +63,7 @@ public static  Plan0 then(/* this */Observable source, Func1(source).then(selector);
     }
+
     /**
      * Joins together the results from several patterns.
      */
@@ -71,6 +73,7 @@ public static  OnSubscribeFunc when(Plan0... plans) {
         }
         return when(Arrays.asList(plans));
     }
+
     /**
      * Joins together the results from several patterns.
      */
@@ -84,12 +87,13 @@ public Subscription onSubscribe(final Observer t1) {
                 final Map externalSubscriptions = new HashMap();
                 final Object gate = new Object();
                 final List activePlans = new ArrayList();
-                
+
                 final Observer out = new Observer() {
                     @Override
                     public void onNext(R args) {
                         t1.onNext(args);
                     }
+
                     @Override
                     public void onError(Throwable e) {
                         for (JoinObserver po : externalSubscriptions.values()) {
@@ -97,12 +101,13 @@ public void onError(Throwable e) {
                         }
                         t1.onError(e);
                     }
+
                     @Override
                     public void onCompleted() {
                         t1.onCompleted();
                     }
                 };
-                
+
                 try {
                     for (Plan0 plan : plans) {
                         activePlans.add(plan.activate(externalSubscriptions, out, new Action1() {
@@ -116,7 +121,7 @@ public void call(ActivePlan0 activePlan) {
                         }));
                     }
                 } catch (Throwable t) {
-                    return Observable.error(t).subscribe(t1);
+                    return Observable. error(t).subscribe(t1);
                 }
                 CompositeSubscription group = new CompositeSubscription();
                 for (JoinObserver jo : externalSubscriptions.values()) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
index 556e007a4a..a24d0f55a3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
@@ -19,6 +19,7 @@
 import java.util.NoSuchElementException;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
@@ -31,8 +32,10 @@
  */
 public final class OperationLatest {
     /** Utility class. */
-    private OperationLatest() { throw new IllegalStateException("No instances!"); }  
-    
+    private OperationLatest() {
+        throw new IllegalStateException("No instances!");
+    }
+
     public static  Iterable latest(final Observable source) {
         return new Iterable() {
             @Override
@@ -43,12 +46,13 @@ public Iterator iterator() {
             }
         };
     }
-    
+
     /** Observer of source, iterator for output. */
     static final class LatestObserverIterator implements Observer>, Iterator {
         final Semaphore notify = new Semaphore(0);
         // observer's notification
         final AtomicReference> reference = new AtomicReference>();
+
         @Override
         public void onNext(Notification args) {
             boolean wasntAvailable = reference.getAndSet(args) == null;
@@ -66,9 +70,10 @@ public void onError(Throwable e) {
         public void onCompleted() {
             // not expected
         }
-        
+
         // iterator's notification
         Notification iNotif;
+
         @Override
         public boolean hasNext() {
             if (iNotif != null && iNotif.isOnError()) {
@@ -83,7 +88,7 @@ public boolean hasNext() {
                         iNotif = new Notification(ex);
                         throw Exceptions.propagate(ex);
                     }
-                    
+
                     iNotif = reference.getAndSet(null);
                     if (iNotif.isOnError()) {
                         throw Exceptions.propagate(iNotif.getThrowable());
@@ -109,6 +114,6 @@ public T next() {
         public void remove() {
             throw new UnsupportedOperationException("Read-only iterator.");
         }
-        
+
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMerge.java b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
index 782c2ae6dd..8080ef0aab 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
@@ -151,8 +151,8 @@ public void onNext(Observable childObservable) {
                 }
 
                 Observable observable = null;
-                synchronized(gate) {
-                    if(activeObservableCount >= maxConcurrent) {
+                synchronized (gate) {
+                    if (activeObservableCount >= maxConcurrent) {
                         pendingObservables.add(childObservable);
                     }
                     else {
@@ -189,7 +189,7 @@ public void onCompleted() {
                 // Try to fetch a pending observable
                 synchronized (gate) {
                     childObservable = pendingObservables.poll();
-                    if(childObservable == null) {
+                    if (childObservable == null) {
                         // There is no pending observable, decrease activeObservableCount.
                         activeObservableCount--;
                     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
index 0d5a1c9378..eff93eeaa5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
@@ -1,12 +1,12 @@
 /**
  * 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.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
index 4e90d3e543..a68d113706 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
@@ -38,9 +38,9 @@ public static  Iterable mostRecent(final Observable source, f
             public Iterator iterator() {
                 MostRecentObserver mostRecentObserver = new MostRecentObserver(initialValue);
                 final MostRecentIterator nextIterator = new MostRecentIterator(mostRecentObserver);
-                
+
                 source.subscribe(mostRecentObserver);
-        
+
                 return nextIterator;
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
index ef310986f5..5fe35d3e65 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
@@ -86,56 +86,60 @@ public void unsubscribe() {
         }
 
     }
+
     /**
-     * Returns an observable sequence that contains the elements of a sequence 
+     * Returns an observable sequence that contains the elements of a sequence
      * produced by multicasting the source sequence within a selector function.
      * 
      * @param source
      * @param subjectFactory
      * @param selector
-     * @return 
+     * @return
      * 
      * @see MSDN: Observable.Multicast
      */
     public static  Observable multicast(
             final Observable source,
-            final Func0> subjectFactory, 
+            final Func0> subjectFactory,
             final Func1, ? extends Observable> selector) {
         return Observable.create(new MulticastSubscribeFunc(source, subjectFactory, selector));
     }
+
     /** The multicast subscription function. */
     private static final class MulticastSubscribeFunc implements OnSubscribeFunc {
         final Observable source;
         final Func0> subjectFactory;
         final Func1, ? extends Observable> resultSelector;
+
         public MulticastSubscribeFunc(Observable source,
-                Func0> subjectFactory, 
+                Func0> subjectFactory,
                 Func1, ? extends Observable> resultSelector) {
             this.source = source;
             this.subjectFactory = subjectFactory;
             this.resultSelector = resultSelector;
         }
+
         @Override
         public Subscription onSubscribe(Observer t1) {
             Observable observable;
             ConnectableObservable connectable;
             try {
                 Subject subject = subjectFactory.call();
-                
+
                 connectable = new MulticastConnectableObservable(source, subject);
-                
+
                 observable = resultSelector.call(connectable);
             } catch (Throwable t) {
                 t1.onError(t);
                 return Subscriptions.empty();
             }
-            
+
             CompositeSubscription csub = new CompositeSubscription();
-            
+
             csub.add(observable.subscribe(new SafeObserver(
                     new SafeObservableSubscription(csub), t1)));
             csub.add(connectable.connect());
-            
+
             return csub;
         }
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java
index 82e6587b20..001dea1c18 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java
@@ -39,13 +39,13 @@ public static  Iterable next(final Observable items) {
             public Iterator iterator() {
                 NextObserver nextObserver = new NextObserver();
                 final NextIterator nextIterator = new NextIterator(nextObserver);
-                
+
                 items.materialize().subscribe(nextObserver);
-                
+
                 return nextIterator;
             }
         };
-        
+
     }
 
     private static class NextIterator implements Iterator {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
index b655d2c53e..e3c3dfa3b2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
@@ -16,7 +16,6 @@
 package rx.operators;
 
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Notification;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
index 1a89b3d2ac..2e1394a74e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
@@ -1,18 +1,18 @@
- /**
-  * 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.
-  */
+/**
+ * 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 java.util.ArrayList;
@@ -24,6 +24,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
+
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
@@ -38,20 +39,23 @@
 
 /**
  * Replay with limited buffer and/or time constraints.
- *
- *
+ * 
+ * 
  * @see MSDN: Observable.Replay overloads
  */
 public final class OperationReplay {
     /** Utility class. */
-    private OperationReplay() { throw new IllegalStateException("No instances!"); }
-    
+    private OperationReplay() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Create a BoundedReplaySubject with the given buffer size.
      */
     public static  Subject replayBuffered(int bufferSize) {
         return CustomReplaySubject.create(bufferSize);
     }
+
     /**
      * Creates a subject whose client observers will observe events
      * propagated through the given wrapped subject.
@@ -61,17 +65,22 @@ public static  Subject createScheduledSubject(Subject subject, Sc
         SubjectWrapper s = new SubjectWrapper(subscriberOf(observedOn), subject);
         return s;
     }
-    
+
     /**
      * Create a CustomReplaySubject with the given time window length
      * and optional buffer size.
      * 
-     * @param  the source and return type
-     * @param time the length of the time window
-     * @param unit the unit of the time window length
-     * @param bufferSize the buffer size if >= 0, otherwise, the buffer will be unlimited
-     * @param scheduler the scheduler from where the current time is retrieved. The
-     *                  observers will not observe on this scheduler.
+     * @param 
+     *            the source and return type
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the unit of the time window length
+     * @param bufferSize
+     *            the buffer size if >= 0, otherwise, the buffer will be unlimited
+     * @param scheduler
+     *            the scheduler from where the current time is retrieved. The
+     *            observers will not observe on this scheduler.
      * @return a Subject with the required replay behavior
      */
     public static  Subject replayWindowed(long time, TimeUnit unit, int bufferSize, final Scheduler scheduler) {
@@ -91,7 +100,7 @@ public T call(Timestamped t1) {
                 return t1.getValue();
             }
         };
-        
+
         ReplayState, T> state;
 
         if (bufferSize >= 0) {
@@ -117,14 +126,14 @@ public void call() {
         };
         // time based eviction when a client subscribes
         state.onSubscription = state.onValueAdded;
-        
+
         final CustomReplaySubject, T> brs = new CustomReplaySubject, T>(
                 new CustomReplaySubjectSubscribeFunc, T>(state), state, timestamp
-        );
-        
+                );
+
         return brs;
     }
-    
+
     /**
      * Return an OnSubscribeFunc which delegates the subscription to the given observable.
      */
@@ -136,7 +145,7 @@ public Subscription onSubscribe(Observer t1) {
             }
         };
     }
-    
+
     /**
      * Subject that wraps another subject and uses a mapping function
      * to transform the received values.
@@ -144,6 +153,7 @@ public Subscription onSubscribe(Observer t1) {
     public static final class MappingSubject extends Subject {
         private final Subject subject;
         private final Func1 selector;
+
         public MappingSubject(OnSubscribeFunc func, Subject subject, Func1 selector) {
             super(func);
             this.subject = subject;
@@ -164,125 +174,149 @@ public void onError(Throwable e) {
         public void onCompleted() {
             subject.onCompleted();
         }
-        
+
     }
-    
+
     /**
      * A subject that wraps another subject.
      */
     public static final class SubjectWrapper extends Subject {
         /** The wrapped subject. */
         final Subject subject;
+
         public SubjectWrapper(OnSubscribeFunc func, Subject subject) {
             super(func);
             this.subject = subject;
         }
-        
+
         @Override
         public void onNext(T args) {
             subject.onNext(args);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             subject.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             subject.onCompleted();
         }
-        
+
     }
-    
+
     /** Base state with lock. */
     static class BaseState {
         /** The lock to protect the other fields. */
         private final Lock lock = new ReentrantLock();
+
         /** Lock. */
         public void lock() {
             lock.lock();
         }
+
         /** Unlock. */
         public void unlock() {
             lock.unlock();
         }
-        
+
     }
+
     /**
      * Base interface for logically indexing a list.
-     * @param  the value type
+     * 
+     * @param 
+     *            the value type
      */
     public interface VirtualList {
         /** @return the number of elements in this list */
         int size();
-        /** 
-         * Add an element to the list. 
-         * @param value the value to add
+
+        /**
+         * Add an element to the list.
+         * 
+         * @param value
+         *            the value to add
          */
         void add(T value);
+
         /**
          * Retrieve an element at the specified logical index.
+         * 
          * @param index
          * @return
          */
         T get(int index);
+
         /**
          * Remove elements up before the given logical index and move
          * the start() to this index.
          * 
    
          * For example, a list contains 3 items. Calling removeUntil 2 will
          * remove the first two items.
+         * 
          * @param index
          */
         void removeBefore(int index);
+
         /**
          * Clear the elements of this list and increase the
          * start by the number of elements.
          */
         void clear();
+
         /**
          * Returns the current head index of this list.
+         * 
          * @return
          */
         int start();
+
         /**
          * Returns the current tail index of this list (where the next value would appear).
+         * 
          * @return
          */
         int end();
+
         /**
          * Clears and resets the indexes of the list.
          */
         void reset();
+
         /**
          * Returns the current content as a list.
-         * @return 
+         * 
+         * @return
          */
         List toList();
     }
+
     /**
      * Behaves like a normal, unbounded ArrayList but with virtual index.
      */
     public static final class VirtualArrayList implements VirtualList {
-        /** The backing list .*/
+        /** The backing list . */
         final List list = new ArrayList();
         /** The virtual start index of the list. */
         int startIndex;
+
         @Override
         public int size() {
             return list.size();
         }
+
         @Override
         public void add(T value) {
             list.add(value);
         }
-        
+
         @Override
         public T get(int index) {
             return list.get(index - startIndex);
         }
-        
+
         @Override
         public void removeBefore(int index) {
             int j = index - startIndex;
@@ -291,34 +325,36 @@ public void removeBefore(int index) {
             }
             startIndex = index;
         }
-        
+
         @Override
         public void clear() {
             startIndex += list.size();
             list.clear();
         }
-        
+
         @Override
         public int start() {
             return startIndex;
         }
-        
+
         @Override
         public int end() {
             return startIndex + list.size();
         }
-        
+
         @Override
         public void reset() {
             list.clear();
             startIndex = 0;
         }
+
         @Override
         public List toList() {
             return new ArrayList(list);
         }
-        
+
     }
+
     /**
      * A bounded list which increases its size up to a maximum capacity, then
      * behaves like a circular buffer with virtual indexes.
@@ -336,8 +372,10 @@ public static final class VirtualBoundedList implements VirtualList {
         int tail;
         /** The number of items in the list. */
         int count;
+
         /**
          * Construct a VirtualBoundedList with the given maximum number of elements.
+         * 
          * @param maxSize
          */
         public VirtualBoundedList(int maxSize) {
@@ -346,16 +384,17 @@ public VirtualBoundedList(int maxSize) {
             }
             this.maxSize = maxSize;
         }
+
         @Override
         public int start() {
             return startIndex;
         }
-        
+
         @Override
         public int end() {
             return startIndex + count;
         }
-        
+
         @Override
         public void clear() {
             startIndex += count;
@@ -364,11 +403,12 @@ public void clear() {
             tail = 0;
             count = 0;
         }
+
         @Override
         public int size() {
             return count;
         }
-        
+
         @Override
         public void add(T value) {
             if (list.size() == maxSize) {
@@ -382,7 +422,7 @@ public void add(T value) {
                 count++;
             }
         }
-        
+
         @Override
         public T get(int index) {
             if (index < start() || index >= end()) {
@@ -391,7 +431,7 @@ public T get(int index) {
             int idx = (head + (index - startIndex)) % maxSize;
             return list.get(idx);
         }
-        
+
         @Override
         public void removeBefore(int index) {
             if (index <= start()) {
@@ -411,6 +451,7 @@ public void removeBefore(int index) {
             startIndex = index;
             head = head2 % maxSize;
         }
+
         @Override
         public List toList() {
             List r = new ArrayList(list.size() + 1);
@@ -420,7 +461,7 @@ public List toList() {
             }
             return r;
         }
-        
+
         @Override
         public void reset() {
             list.clear();
@@ -428,12 +469,16 @@ public void reset() {
             head = 0;
             tail = 0;
         }
-        
+
     }
-    /** 
-     * The state class. 
-     * @param  the intermediate type stored in the values buffer
-     * @param  the result type transformed via the resultSelector
+
+    /**
+     * The state class.
+     * 
+     * @param 
+     *            the intermediate type stored in the values buffer
+     * @param 
+     *            the result type transformed via the resultSelector
      */
     static final class ReplayState extends BaseState {
         /** The values observed so far. */
@@ -490,49 +535,56 @@ public void call() {
             public void call() {
             }
         };
+
         /**
          * Construct a ReplayState with the supplied buffer and result selectors.
+         * 
          * @param values
-         * @param resultSelector 
+         * @param resultSelector
          */
         public ReplayState(final VirtualList values,
-            final Func1 resultSelector) {
+                final Func1 resultSelector) {
             this.values = values;
             this.resultSelector = resultSelector;
         }
+
         /**
          * Returns a live collection of the observers.
          * 
    
          * Caller should hold the lock.
+         * 
          * @return
          */
         Collection replayers() {
             return new ArrayList(replayers.values());
         }
+
         /**
          * Add a replayer to the replayers and create a Subscription for it.
          * 
    
          * Caller should hold the lock.
-         *
+         * 
          * @param obs
          * @return
          */
         Subscription addReplayer(Observer obs) {
             Subscription s = new Subscription() {
                 final AtomicBoolean once = new AtomicBoolean();
+
                 @Override
                 public void unsubscribe() {
                     if (once.compareAndSet(false, true)) {
                         remove(this);
                     }
                 }
-                
+
             };
             Replayer rp = new Replayer(obs, s);
             replayers.put(s, rp);
             rp.replayTill(values.start() + values.size());
             return s;
         }
+
         /** The replayer that holds a value where the given observer is currently at. */
         final class Replayer {
             protected final Observer wrapped;
@@ -540,12 +592,15 @@ final class Replayer {
             protected int index;
             /** To cancel and unsubscribe this replayer and observer. */
             protected final Subscription cancel;
+
             protected Replayer(Observer wrapped, Subscription cancel) {
                 this.wrapped = wrapped;
                 this.cancel = cancel;
             }
+
             /**
              * Replay up to the given index
+             * 
              * @param limit
              */
             void replayTill(int limit) {
@@ -573,8 +628,10 @@ void replayTill(int limit) {
                 }
             }
         }
+
         /**
          * Remove the subscription.
+         * 
          * @param s
          */
         void remove(Subscription s) {
@@ -585,15 +642,18 @@ void remove(Subscription s) {
                 unlock();
             }
         }
+
         /**
          * Add a notification value and limit the size of values.
          * 
    
          * Caller should hold the lock.
+         * 
          * @param value
          */
         void add(TIntermediate value) {
             values.add(value);
         }
+
         /** Clears the value list. */
         void clearValues() {
             lock();
@@ -604,50 +664,58 @@ void clearValues() {
             }
         }
     }
+
     /**
      * A customizable replay subject with support for transformations.
      * 
-     * @param  the Observer side's value type
-     * @param  the type of the elements in the replay buffer
-     * @param  the value type of the observers subscribing to this subject
+     * @param 
+     *            the Observer side's value type
+     * @param 
+     *            the type of the elements in the replay buffer
+     * @param 
+     *            the value type of the observers subscribing to this subject
      */
     public static final class CustomReplaySubject extends Subject {
         /**
          * Return a subject that retains all events and will replay them to an {@link Observer} that subscribes.
+         * 
          * @return a subject that retains all events and will replay them to an {@link Observer} that subscribes.
          */
         public static  CustomReplaySubject create() {
-            ReplayState state = new ReplayState(new VirtualArrayList(), Functions.identity());
+            ReplayState state = new ReplayState(new VirtualArrayList(), Functions. identity());
             return new CustomReplaySubject(
-                    new CustomReplaySubjectSubscribeFunc(state), state, 
-                    Functions.identity());
+                    new CustomReplaySubjectSubscribeFunc(state), state,
+                    Functions. identity());
         }
+
         /**
          * Create a bounded replay subject with the given maximum buffer size.
-         * @param maxSize the maximum size in number of onNext notifications
+         * 
+         * @param maxSize
+         *            the maximum size in number of onNext notifications
          * @return
          */
         public static  CustomReplaySubject create(int maxSize) {
-            ReplayState state = new ReplayState(new VirtualBoundedList(maxSize), Functions.identity());
+            ReplayState state = new ReplayState(new VirtualBoundedList(maxSize), Functions. identity());
             return new CustomReplaySubject(
-                    new CustomReplaySubjectSubscribeFunc(state), state, 
-                    Functions.identity());
+                    new CustomReplaySubjectSubscribeFunc(state), state,
+                    Functions. identity());
         }
+
         /** The replay state. */
         protected final ReplayState state;
         /** The result selector. */
         protected final Func1 intermediateSelector;
-        
+
         private CustomReplaySubject(
-                Observable.OnSubscribeFunc onSubscribe, 
+                Observable.OnSubscribeFunc onSubscribe,
                 ReplayState state,
                 Func1 intermediateSelector) {
             super(onSubscribe);
             this.state = state;
             this.intermediateSelector = intermediateSelector;
         }
-        
-        
+
         @Override
         public void onCompleted() {
             state.lock();
@@ -662,7 +730,7 @@ public void onCompleted() {
                 state.unlock();
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             state.lock();
@@ -678,7 +746,7 @@ public void onError(Throwable e) {
                 state.unlock();
             }
         }
-        
+
         @Override
         public void onNext(TInput args) {
             state.lock();
@@ -693,6 +761,7 @@ public void onNext(TInput args) {
                 state.unlock();
             }
         }
+
         /**
          * Replay values up to the current index.
          */
@@ -703,19 +772,24 @@ protected void replayValues() {
             }
         }
     }
-    /** 
-     * The subscription function. 
-     * @param  the type of the elements in the replay buffer
-     * @param  the value type of the observers subscribing to this subject
+
+    /**
+     * The subscription function.
+     * 
+     * @param 
+     *            the type of the elements in the replay buffer
+     * @param 
+     *            the value type of the observers subscribing to this subject
      */
-    protected static final class CustomReplaySubjectSubscribeFunc 
-    implements Observable.OnSubscribeFunc {
-        
+    protected static final class CustomReplaySubjectSubscribeFunc
+            implements Observable.OnSubscribeFunc {
+
         private final ReplayState state;
+
         protected CustomReplaySubjectSubscribeFunc(ReplayState state) {
             this.state = state;
         }
-        
+
         @Override
         public Subscription onSubscribe(Observer t1) {
             VirtualList values;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
index a7fb426bf1..f2badbe6f7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java
@@ -116,21 +116,26 @@ public void call() {
             });
         }
     }
-    /** 
-     * Sample with the help of another observable. 
+
+    /**
+     * Sample with the help of another observable.
+     * 
      * @see MSDN: Observable.Sample
      */
     public static class SampleWithObservable implements OnSubscribeFunc {
         final Observable source;
         final Observable sampler;
+
         public SampleWithObservable(Observable source, Observable sampler) {
             this.source = source;
             this.sampler = sampler;
         }
+
         @Override
         public Subscription onSubscribe(Observer t1) {
             return new ResultManager(t1).init();
         }
+
         /** Observe source values. */
         class ResultManager implements Observer {
             final Observer observer;
@@ -139,17 +144,20 @@ class ResultManager implements Observer {
             boolean valueTaken = true;
             boolean done;
             final Object guard;
+
             public ResultManager(Observer observer) {
                 this.observer = observer;
                 cancel = new CompositeSubscription();
                 guard = new Object();
             }
+
             public Subscription init() {
                 cancel.add(source.subscribe(this));
                 cancel.add(sampler.subscribe(new Sampler()));
-                
+
                 return cancel;
             }
+
             @Override
             public void onNext(T args) {
                 synchronized (guard) {
@@ -168,7 +176,7 @@ public void onError(Throwable e) {
                     }
                 }
             }
-            
+
             @Override
             public void onCompleted() {
                 synchronized (guard) {
@@ -179,6 +187,7 @@ public void onCompleted() {
                     }
                 }
             }
+
             /** Take the latest value, but only once. */
             class Sampler implements Observer {
                 @Override
@@ -188,7 +197,7 @@ public void onNext(U args) {
                             valueTaken = true;
                             observer.onNext(value);
                         }
-                    }                
+                    }
                 }
 
                 @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 0b33fb0af9..96dc644ae2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -112,10 +112,12 @@ public void onNext(T args) {
         }
 
     }
-    
-    /** 
-     * Skip the items after subscription for the given duration. 
-     * @param  the value type
+
+    /**
+     * Skip the items after subscription for the given duration.
+     * 
+     * @param 
+     *            the value type
      */
     public static final class SkipTimed implements OnSubscribeFunc {
         final Observable source;
@@ -132,30 +134,33 @@ public SkipTimed(Observable source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer t1) {
-            
+
             SafeObservableSubscription timer = new SafeObservableSubscription();
             SafeObservableSubscription data = new SafeObservableSubscription();
 
             CompositeSubscription csub = new CompositeSubscription(timer, data);
-            
+
             SourceObserver so = new SourceObserver(t1, csub);
             data.wrap(source.subscribe(so));
             if (!data.isUnsubscribed()) {
                 timer.wrap(scheduler.schedule(so, time, unit));
             }
-            
+
             return csub;
         }
+
         /**
          * Observes the source and relays its values once gate turns into true.
-         * @param  the observed value type
+         * 
+         * @param 
+         *            the observed value type
          */
         private static final class SourceObserver implements Observer, Action0 {
             final AtomicBoolean gate;
             final Observer observer;
             final Subscription cancel;
 
-            public SourceObserver(Observer observer, 
+            public SourceObserver(Observer observer,
                     Subscription cancel) {
                 this.gate = new AtomicBoolean();
                 this.observer = observer;
@@ -186,12 +191,12 @@ public void onCompleted() {
                     cancel.unsubscribe();
                 }
             }
-            
+
             @Override
             public void call() {
                 gate.set(true);
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index a25186a4d1..85d7bbfa70 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -129,10 +129,12 @@ public void onNext(T value) {
             }));
         }
     }
-    
+
     /**
      * Skip delivering values in the time window before the values.
-     * @param  the result value type
+     * 
+     * @param 
+     *            the result value type
      */
     public static final class SkipLastTimed implements OnSubscribeFunc {
         final Observable source;
@@ -149,6 +151,7 @@ public SkipLastTimed(Observable source, long time, TimeUnit unit, S
         public Subscription onSubscribe(Observer t1) {
             return source.subscribe(new SourceObserver(t1, timeInMillis, scheduler));
         }
+
         /** Observes the source. */
         private static final class SourceObserver implements Observer {
             final Observer observer;
@@ -156,7 +159,7 @@ private static final class SourceObserver implements Observer {
             final Scheduler scheduler;
             List> buffer = new ArrayList>();
 
-            public SourceObserver(Observer observer, 
+            public SourceObserver(Observer observer,
                     long timeInMillis, Scheduler scheduler) {
                 this.observer = observer;
                 this.timeInMillis = timeInMillis;
@@ -195,7 +198,7 @@ public void onCompleted() {
                     buffer = Collections.emptyList();
                 }
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
index 7e89b741e8..4486d4df08 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
@@ -33,6 +33,7 @@
 public class OperationSkipUntil implements OnSubscribeFunc {
     protected final Observable source;
     protected final Observable other;
+
     public OperationSkipUntil(Observable source, Observable other) {
         this.source = source;
         this.other = other;
@@ -42,27 +43,30 @@ public OperationSkipUntil(Observable source, Observable other) {
     public Subscription onSubscribe(Observer t1) {
         return new ResultManager(t1).init();
     }
+
     /** Manage the source and other observers. */
     private class ResultManager implements Subscription, Observer {
         final Observer observer;
         final CompositeSubscription cancel;
         final Object guard = new Object();
         final AtomicBoolean running = new AtomicBoolean();
+
         public ResultManager(Observer observer) {
             this.observer = observer;
             this.cancel = new CompositeSubscription();
         }
+
         public ResultManager init() {
-            
+
             SerialSubscription toSource = new SerialSubscription();
             SerialSubscription toOther = new SerialSubscription();
-            
+
             cancel.add(toSource);
             cancel.add(toOther);
-            
+
             toSource.setSubscription(source.subscribe(this));
             toOther.setSubscription(other.subscribe(new OtherObserver(toOther)));
-            
+
             return this;
         }
 
@@ -93,10 +97,11 @@ public void onCompleted() {
                 unsubscribe();
             }
         }
-        
+
         /** Observe the other stream. */
         private class OtherObserver implements Observer {
             final Subscription self;
+
             public OtherObserver(Subscription self) {
                 this.self = self;
             }
@@ -116,7 +121,7 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 self.unsubscribe();
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
index 8f419bd222..b05d3d605c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSum.java
@@ -16,7 +16,6 @@
 package rx.operators;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Func1;
@@ -63,11 +62,13 @@ public Double call(Double accu, Double next) {
             }
         });
     }
-    
+
     /**
      * Compute the sum by extracting integer values from the source via an
      * extractor function.
-     * @param  the source value type
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class SumIntegerExtractor implements Observable.OnSubscribeFunc {
         final Observable source;
@@ -82,11 +83,13 @@ public SumIntegerExtractor(Observable source, Func1 t1) {
             return source.subscribe(new SumObserver(t1));
         }
+
         /** Computes the average. */
         private final class SumObserver implements Observer {
             final Observer observer;
             int sum;
             boolean hasValue;
+
             public SumObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -116,14 +119,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
-    
+
     /**
      * Compute the sum by extracting long values from the source via an
      * extractor function.
-     * @param  the source value type
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class SumLongExtractor implements Observable.OnSubscribeFunc {
         final Observable source;
@@ -138,11 +143,13 @@ public SumLongExtractor(Observable source, Func1 v
         public Subscription onSubscribe(Observer t1) {
             return source.subscribe(new SumObserver(t1));
         }
+
         /** Computes the average. */
         private final class SumObserver implements Observer {
             final Observer observer;
             long sum;
             boolean hasValue;
+
             public SumObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -172,14 +179,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
-    
+
     /**
      * Compute the sum by extracting float values from the source via an
      * extractor function.
-     * @param  the source value type
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class SumFloatExtractor implements Observable.OnSubscribeFunc {
         final Observable source;
@@ -194,11 +203,13 @@ public SumFloatExtractor(Observable source, Func1
         public Subscription onSubscribe(Observer t1) {
             return source.subscribe(new SumObserver(t1));
         }
+
         /** Computes the average. */
         private final class SumObserver implements Observer {
             final Observer observer;
             float sum;
             boolean hasValue;
+
             public SumObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -228,14 +239,16 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
 
     /**
      * Compute the sum by extracting float values from the source via an
      * extractor function.
-     * @param  the source value type
+     * 
+     * @param 
+     *            the source value type
      */
     public static final class SumDoubleExtractor implements Observable.OnSubscribeFunc {
         final Observable source;
@@ -250,11 +263,13 @@ public SumDoubleExtractor(Observable source, Func1 t1) {
             return source.subscribe(new SumObserver(t1));
         }
+
         /** Computes the average. */
         private final class SumObserver implements Observer {
             final Observer observer;
             double sum;
             boolean hasValue;
+
             public SumObserver(Observer observer) {
                 this.observer = observer;
             }
@@ -284,7 +299,7 @@ public void onCompleted() {
                     observer.onError(new IllegalArgumentException("Sequence contains no elements"));
                 }
             }
-            
+
         }
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 634801f19b..94d80b3436 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -117,7 +117,7 @@ public void onError(Throwable e) {
                             s = SwitchObserver.this.parent;
                         }
                     }
-                    if(s != null) {
+                    if (s != null) {
                         s.unsubscribe();
                     }
                 }
@@ -136,7 +136,7 @@ public void onCompleted() {
                             }
                         }
                     }
-                    if(s != null) {
+                    if (s != null) {
                         s.unsubscribe();
                     }
                 }
@@ -165,7 +165,7 @@ public void onCompleted() {
                     s = this.parent;
                 }
             }
-            if(s != null) {
+            if (s != null) {
                 s.unsubscribe();
             }
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTake.java b/rxjava-core/src/main/java/rx/operators/OperationTake.java
index 797eb47d43..9096e6a906 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTake.java
@@ -165,10 +165,12 @@ public void onNext(T args) {
         }
 
     }
-    
+
     /**
      * Takes values from the source until a timer fires.
-     * @param  the result value type
+     * 
+     * @param 
+     *            the result value type
      */
     public static final class TakeTimed implements OnSubscribeFunc {
         final Observable source;
@@ -185,23 +187,26 @@ public TakeTimed(Observable source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer t1) {
-            
+
             SafeObservableSubscription timer = new SafeObservableSubscription();
             SafeObservableSubscription data = new SafeObservableSubscription();
 
             CompositeSubscription csub = new CompositeSubscription(timer, data);
-            
+
             SourceObserver so = new SourceObserver(t1, csub);
             data.wrap(source.subscribe(so));
             if (!data.isUnsubscribed()) {
                 timer.wrap(scheduler.schedule(so, time, unit));
             }
-            
+
             return csub;
         }
+
         /**
          * Observes the source and relays its values until gate turns into false.
-         * @param  the observed value type
+         * 
+         * @param 
+         *            the observed value type
          */
         private static final class SourceObserver implements Observer, Action0 {
             final Observer observer;
@@ -211,7 +216,7 @@ private static final class SourceObserver implements Observer, Action0 {
             static final int NEXT = 1;
             static final int DONE = 2;
 
-            public SourceObserver(Observer observer, 
+            public SourceObserver(Observer observer,
                     Subscription cancel) {
                 this.observer = observer;
                 this.cancel = cancel;
@@ -241,11 +246,9 @@ public void onError(Throwable e) {
                     int s = state.get();
                     if (s == DONE) {
                         return;
-                    } else
-                    if (s == NEXT) {
+                    } else if (s == NEXT) {
                         continue;
-                    } else
-                    if (state.compareAndSet(s, DONE)) {
+                    } else if (state.compareAndSet(s, DONE)) {
                         try {
                             observer.onError(e);
                         } finally {
@@ -262,11 +265,9 @@ public void onCompleted() {
                     int s = state.get();
                     if (s == DONE) {
                         return;
-                    } else
-                    if (s == NEXT) {
+                    } else if (s == NEXT) {
                         continue;
-                    } else
-                    if (state.compareAndSet(s, DONE)) {
+                    } else if (state.compareAndSet(s, DONE)) {
                         try {
                             observer.onCompleted();
                         } finally {
@@ -281,7 +282,7 @@ public void onCompleted() {
             public void call() {
                 onCompleted();
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index e0054704b6..e11910fa68 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -25,7 +25,6 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.subscriptions.BooleanSubscription;
 import rx.util.Timestamped;
 
 /**
@@ -123,7 +122,7 @@ public void onNext(T value) {
         }
 
     }
-    
+
     /**
      * Returns the items emitted by source whose arrived in the time window
      * before the source completed.
@@ -131,7 +130,7 @@ public void onNext(T value) {
     public static  OnSubscribeFunc takeLast(Observable source, long time, TimeUnit unit, Scheduler scheduler) {
         return new TakeLastTimed(source, -1, time, unit, scheduler);
     }
-    
+
     /**
      * Returns the items emitted by source whose arrived in the time window
      * before the source completed and at most count values.
@@ -139,7 +138,7 @@ public static  OnSubscribeFunc takeLast(Observable source, lo
     public static  OnSubscribeFunc takeLast(Observable source, int count, long time, TimeUnit unit, Scheduler scheduler) {
         return new TakeLastTimed(source, count, time, unit, scheduler);
     }
-    
+
     /** Take only the values which appeared some time before the completion. */
     static final class TakeLastTimed implements OnSubscribeFunc {
         final Observable source;
@@ -161,6 +160,7 @@ public Subscription onSubscribe(Observer t1) {
             return sas;
         }
     }
+
     /** Observes source values and keeps the most recent items. */
     static final class TakeLastTimedObserver implements Observer {
         final Observer observer;
@@ -169,10 +169,10 @@ static final class TakeLastTimedObserver implements Observer {
         final Scheduler scheduler;
         /** -1 indicates unlimited buffer. */
         final int count;
-        
+
         final Deque> buffer = new LinkedList>();
 
-        public TakeLastTimedObserver(Observer observer, Subscription cancel, 
+        public TakeLastTimedObserver(Observer observer, Subscription cancel,
                 int count, long ageMillis, Scheduler scheduler) {
             this.observer = observer;
             this.cancel = cancel;
@@ -196,7 +196,7 @@ protected void runEvictionPolicy(long now) {
                 }
             }
         }
-        
+
         @Override
         public void onNext(T args) {
             long t = scheduler.now();
@@ -211,8 +211,9 @@ public void onError(Throwable e) {
             cancel.unsubscribe();
         }
 
-        /** 
-         * Emit the contents of the buffer. 
+        /**
+         * Emit the contents of the buffer.
+         * 
          * @return true if no exception was raised in the process
          */
         protected boolean emitBuffer() {
@@ -228,7 +229,7 @@ protected boolean emitBuffer() {
             buffer.clear();
             return true;
         }
-        
+
         @Override
         public void onCompleted() {
             runEvictionPolicy(scheduler.now());
@@ -238,6 +239,6 @@ public void onCompleted() {
             }
             cancel.unsubscribe();
         }
-        
+
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
index f93bfd2eec..408cd73df7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
@@ -156,12 +156,12 @@ public void onCompleted() {
             return composite;
         }
     }
-    
+
     /** Timeout using a per-item observable sequence. */
     public static  OnSubscribeFunc timeoutSelector(Observable source, Func0> firstValueTimeout, Func1> valueTimeout, Observable other) {
         return new TimeoutSelector(source, firstValueTimeout, valueTimeout, other);
     }
-    
+
     /** Timeout using a per-item observable sequence. */
     private static final class TimeoutSelector implements OnSubscribeFunc {
         final Observable source;
@@ -189,13 +189,13 @@ public Subscription onSubscribe(Observer t1) {
                     t1.onError(t);
                     return Subscriptions.empty();
                 }
-                
+
                 csub.add(o.subscribe(new TimeoutObserver(so)));
             }
             csub.add(source.subscribe(so));
             return csub;
         }
-        
+
         /** Observe the source. */
         private static final class SourceObserver implements Observer, TimeoutCallback {
             final Observer observer;
@@ -221,14 +221,14 @@ public SourceObserver(Observer observer, Func1 o;
                 try {
                     o = valueTimeout.call(args);
@@ -236,12 +236,13 @@ public void onNext(T args) {
                     onError(t);
                     return;
                 }
-                
+
                 SerialSubscription osub = new SerialSubscription();
                 tsub.set(osub);
-                
+
                 osub.set(o.subscribe(to));
             }
+
             @Override
             public void onError(Throwable e) {
                 synchronized (guard) {
@@ -265,6 +266,7 @@ public void onCompleted() {
                 }
                 cancel.unsubscribe();
             }
+
             @Override
             public void timeout() {
                 if (other != null) {
@@ -281,13 +283,14 @@ public void timeout() {
                 }
             }
         }
-        
+
         /** The timeout callback. */
         private interface TimeoutCallback {
             void timeout();
+
             void onError(Throwable t);
         }
-        
+
         /** Observe the timeout. */
         private static final class TimeoutObserver implements Observer {
             final TimeoutCallback parent;
@@ -295,7 +298,7 @@ private static final class TimeoutObserver implements Observer {
             public TimeoutObserver(TimeoutCallback parent) {
                 this.parent = parent;
             }
-            
+
             @Override
             public void onNext(V args) {
                 parent.timeout();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 34a82e8eab..6b7cdbe25c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -1,21 +1,22 @@
- /**
-  * 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.
-  */
+/**
+ * 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 java.util.concurrent.TimeUnit;
+
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
@@ -24,12 +25,14 @@
 
 /**
  * Operation Timer with several overloads.
- *
+ * 
  * @see MSDN Observable.Timer
  */
 public final class OperationTimer {
-    private OperationTimer() { throw new IllegalStateException("No instances!"); }
-    
+    private OperationTimer() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Emit a single 0L after the specified time elapses.
      */
@@ -37,12 +40,13 @@ public static class TimerOnce implements OnSubscribeFunc {
         private final Scheduler scheduler;
         private final long dueTime;
         private final TimeUnit dueUnit;
+
         public TimerOnce(long dueTime, TimeUnit unit, Scheduler scheduler) {
             this.scheduler = scheduler;
             this.dueTime = dueTime;
             this.dueUnit = unit;
         }
-        
+
         @Override
         public Subscription onSubscribe(final Observer t1) {
             return scheduler.schedule(new Action0() {
@@ -51,10 +55,11 @@ public void call() {
                     t1.onNext(0L);
                     t1.onCompleted();
                 }
-                
+
             }, dueTime, dueUnit);
         }
     }
+
     /**
      * Emit 0L after the initial period and ever increasing number after each period.
      */
@@ -63,24 +68,26 @@ public static class TimerPeriodically implements OnSubscribeFunc {
         private final long initialDelay;
         private final long period;
         private final TimeUnit unit;
+
         public TimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
             this.scheduler = scheduler;
             this.initialDelay = initialDelay;
             this.period = period;
             this.unit = unit;
         }
-        
+
         @Override
         public Subscription onSubscribe(final Observer t1) {
             return scheduler.schedulePeriodically(new Action0() {
                 long count;
+
                 @Override
                 public void call() {
                     t1.onNext(count++);
                 }
             },
-            initialDelay, period, unit
-            );
+                    initialDelay, period, unit
+                    );
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
index a1044ba748..a56e82c0bd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
@@ -45,6 +45,7 @@ public Timestamped call(T value) {
             }
         });
     }
+
     /**
      * Timestamp the source elements based on the timing provided by the scheduler.
      */
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
index 9760805fdc..038c0ba38c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
@@ -64,7 +64,7 @@ public void onNext(Notification args) {
 
         return new Iterator() {
             private Notification buf;
-            
+
             @Override
             public boolean hasNext() {
                 if (buf == null) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
index 12963ce6a4..770d4d68a3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
@@ -41,7 +41,7 @@ public class OperationToMap {
     public static  OnSubscribeFunc> toMap(Observable source,
             Func1 keySelector) {
         return new ToMap(source, keySelector,
-        Functions.identity(), new DefaultToMapFactory());
+                Functions. identity(), new DefaultToMapFactory());
     }
 
     /**
@@ -51,7 +51,7 @@ public static  OnSubscribeFunc> toMap(Observable source,
             Func1 keySelector,
             Func1 valueSelector) {
         return new ToMap(source, keySelector,
-        valueSelector, new DefaultToMapFactory());
+                valueSelector, new DefaultToMapFactory());
     }
 
     /**
@@ -62,7 +62,7 @@ public static  OnSubscribeFunc> toMap(Observable source,
             Func1 valueSelector,
             Func0> mapFactory) {
         return new ToMap(source, keySelector,
-        valueSelector, mapFactory);
+                valueSelector, mapFactory);
     }
 
     /** The default map factory. */
@@ -72,13 +72,18 @@ public Map call() {
             return new HashMap();
         }
     }
+
     /**
      * Maps the elements of the source observable into a java.util.Map instance
      * returned by the mapFactory function by using the keySelector and
      * valueSelector.
-     * @param  the source's value type
-     * @param  the key type
-     * @param  the value type
+     * 
+     * @param 
+     *            the source's value type
+     * @param 
+     *            the key type
+     * @param 
+     *            the value type
      */
     public static class ToMap implements OnSubscribeFunc> {
         /** The source. */
@@ -89,18 +94,19 @@ public static class ToMap implements OnSubscribeFunc> {
         private final Func1 valueSelector;
         /** Map factory. */
         private final Func0> mapFactory;
+
         public ToMap(
                 Observable source,
                 Func1 keySelector,
                 Func1 valueSelector,
-                Func0> mapFactory
-                ) {
+                Func0> mapFactory) {
             this.source = source;
             this.keySelector = keySelector;
             this.valueSelector = valueSelector;
             this.mapFactory = mapFactory;
-            
+
         }
+
         @Override
         public Subscription onSubscribe(Observer> t1) {
             Map map;
@@ -113,6 +119,7 @@ public Subscription onSubscribe(Observer> t1) {
             return source.subscribe(new ToMapObserver(
                     t1, keySelector, valueSelector, map));
         }
+
         /**
          * Observer that collects the source values of T into
          * a map.
@@ -126,9 +133,9 @@ public static class ToMapObserver implements Observer {
             private final Func1 valueSelector;
             /** The observer who is receiving the completed map. */
             private final Observer> t1;
-            
+
             public ToMapObserver(
-                    Observer> t1, 
+                    Observer> t1,
                     Func1 keySelector,
                     Func1 valueSelector,
                     Map map) {
@@ -137,17 +144,20 @@ public ToMapObserver(
                 this.keySelector = keySelector;
                 this.valueSelector = valueSelector;
             }
+
             @Override
             public void onNext(T args) {
                 K key = keySelector.call(args);
                 V value = valueSelector.call(args);
                 map.put(key, value);
             }
+
             @Override
             public void onError(Throwable e) {
                 map = null;
                 t1.onError(e);
             }
+
             @Override
             public void onCompleted() {
                 Map map0 = map;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
index 92e8f68432..98d469b65f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
@@ -31,7 +31,7 @@
 import rx.util.functions.Functions;
 
 /**
- * Maps the elements of the source observable into a multimap 
+ * Maps the elements of the source observable into a multimap
  * (Map<K, Collection<V>>) where each
  * key entry has a collection of the source's values.
  * 
@@ -45,12 +45,11 @@ public class OperationToMultimap {
     public static  OnSubscribeFunc>> toMultimap(
             Observable source,
             Func1 keySelector
-    ) {
+            ) {
         return new ToMultimap(
-                source, keySelector, Functions.identity(),
+                source, keySelector, Functions. identity(),
                 new DefaultToMultimapFactory(),
-                new DefaultMultimapCollectionFactory()
-        );
+                new DefaultMultimapCollectionFactory());
     }
 
     /**
@@ -61,13 +60,13 @@ public static  OnSubscribeFunc>> toMultimap(
             Observable source,
             Func1 keySelector,
             Func1 valueSelector
-    ) {
+            ) {
         return new ToMultimap(
                 source, keySelector, valueSelector,
                 new DefaultToMultimapFactory(),
-                new DefaultMultimapCollectionFactory()
-        );
+                new DefaultMultimapCollectionFactory());
     }
+
     /**
      * ToMultimap with key selector, custom value selector,
      * custom Map factory and default ArrayList collection factory.
@@ -77,13 +76,13 @@ public static  OnSubscribeFunc>> toMultimap(
             Func1 keySelector,
             Func1 valueSelector,
             Func0>> mapFactory
-    ) {
+            ) {
         return new ToMultimap(
                 source, keySelector, valueSelector,
                 mapFactory,
-                new DefaultMultimapCollectionFactory()
-        );
+                new DefaultMultimapCollectionFactory());
     }
+
     /**
      * ToMultimap with key selector, custom value selector,
      * custom Map factory and custom collection factory.
@@ -94,13 +93,13 @@ public static  OnSubscribeFunc>> toMultimap(
             Func1 valueSelector,
             Func0>> mapFactory,
             Func1> collectionFactory
-    ) {
+            ) {
         return new ToMultimap(
                 source, keySelector, valueSelector,
                 mapFactory,
-                collectionFactory
-        );
+                collectionFactory);
     }
+
     /**
      * The default multimap factory returning a HashMap.
      */
@@ -110,17 +109,19 @@ public Map> call() {
             return new HashMap>();
         }
     }
+
     /**
      * The default collection factory for a key in the multimap returning
      * an ArrayList independent of the key.
      */
     public static class DefaultMultimapCollectionFactory
-    implements Func1> {
+            implements Func1> {
         @Override
         public Collection call(K t1) {
             return new ArrayList();
         }
     }
+
     /**
      * Maps the elements of the source observable int a multimap customized
      * by various selectors and factories.
@@ -131,19 +132,20 @@ public static class ToMultimap implements OnSubscribeFunc valueSelector;
         private final Func0>> mapFactory;
         private final Func1> collectionFactory;
+
         public ToMultimap(
                 Observable source,
                 Func1 keySelector,
                 Func1 valueSelector,
                 Func0>> mapFactory,
-                Func1> collectionFactory
-        ) {
+                Func1> collectionFactory) {
             this.source = source;
             this.keySelector = keySelector;
             this.valueSelector = valueSelector;
             this.mapFactory = mapFactory;
             this.collectionFactory = collectionFactory;
         }
+
         @Override
         public Subscription onSubscribe(Observer>> t1) {
             Map> map;
@@ -155,8 +157,9 @@ public Subscription onSubscribe(Observer>> t1) {
             }
             return source.subscribe(new ToMultimapObserver(
                     t1, keySelector, valueSelector, map, collectionFactory
-            ));
+                    ));
         }
+
         /**
          * Observer that collects the source values of Ts into a multimap.
          */
@@ -166,19 +169,20 @@ public static class ToMultimapObserver implements Observer {
             private final Func1> collectionFactory;
             private Map> map;
             private Observer>> t1;
+
             public ToMultimapObserver(
-                Observer>> t1,
-                Func1 keySelector,
-                Func1 valueSelector,
-                Map> map,
-                Func1> collectionFactory
-            ) {
+                    Observer>> t1,
+                    Func1 keySelector,
+                    Func1 valueSelector,
+                    Map> map,
+                    Func1> collectionFactory) {
                 this.t1 = t1;
                 this.keySelector = keySelector;
                 this.valueSelector = valueSelector;
                 this.collectionFactory = collectionFactory;
                 this.map = map;
             }
+
             @Override
             public void onNext(T args) {
                 K key = keySelector.call(args);
@@ -190,11 +194,13 @@ public void onNext(T args) {
                 }
                 collection.add(value);
             }
+
             @Override
             public void onError(Throwable e) {
                 map = null;
                 t1.onError(e);
             }
+
             @Override
             public void onCompleted() {
                 Map> map0 = map;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
index 4518715908..77d93e3851 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
@@ -15,18 +15,17 @@
  */
 package rx.operators;
 
+import java.util.Iterator;
+
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.schedulers.ImmediateScheduler;
-import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
-import java.util.Iterator;
-
 /**
  * Converts an Iterable sequence into an Observable.
  * 
    
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
index 0ec59d71b2..f29582537e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
@@ -17,7 +17,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationUsing.java b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
index dd0cc38d65..dd2a588c2b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationUsing.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index c1026241a2..0f99b8e66e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -358,6 +358,7 @@ public Observable getContents() {
             return Observable.from(contents);
         }
     }
+
     /**
      * Emits windows of values of the source Observable where the window boundary is
      * determined by the items of the boundary Observable.
@@ -365,6 +366,7 @@ public Observable getContents() {
     public static  OnSubscribeFunc> window(Observable source, Observable boundary) {
         return new WindowViaObservable(source, boundary);
     }
+
     /**
      * Create non-overlapping windows from the source values by using another observable's
      * values as to when to replace a window.
@@ -390,13 +392,14 @@ public Subscription onSubscribe(Observer> t1) {
                 return Subscriptions.empty();
             }
             csub.add(source.subscribe(so));
-            
+
             if (!csub.isUnsubscribed()) {
                 csub.add(boundary.subscribe(new BoundaryObserver(so)));
             }
-            
+
             return csub;
         }
+
         /**
          * Observe the source and emit the values into the current window.
          */
@@ -416,6 +419,7 @@ public SourceObserver(Observer> observer, Subscription can
             Subject create() {
                 return PublishSubject.create();
             }
+
             @Override
             public void onNext(T args) {
                 synchronized (guard) {
@@ -434,7 +438,7 @@ public void onError(Throwable e) {
                     }
                     Subject s = subject;
                     subject = null;
-    
+
                     s.onError(e);
                     observer.onError(e);
                 }
@@ -449,12 +453,13 @@ public void onCompleted() {
                     }
                     Subject s = subject;
                     subject = null;
-                    
+
                     s.onCompleted();
                     observer.onCompleted();
                 }
                 cancel.unsubscribe();
             }
+
             public void replace() {
                 try {
                     synchronized (guard) {
@@ -472,6 +477,7 @@ public void replace() {
                 }
             }
         }
+
         /**
          * Observe the boundary and replace the window on each item.
          */
diff --git a/rxjava-core/src/main/java/rx/operators/OperationZip.java b/rxjava-core/src/main/java/rx/operators/OperationZip.java
index 093eeb74d0..bb6bec6d4a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationZip.java
@@ -1,12 +1,12 @@
 /**
  * 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.
@@ -57,56 +57,56 @@
  * number of onNext invocations of the source Observable that emits the fewest items.
  */
 public final class OperationZip {
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, final Func2 zipFunction) {
         return zip(Arrays.asList(o1, o2), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, final Func3 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, final Func4 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, final Func5 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6,
             final Func6 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7,
             final Func7 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
             final Func8 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(zipFunction));
     }
-    
+
     @SuppressWarnings("unchecked")
     public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
             Observable o9, final Func9 zipFunction) {
         return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(zipFunction));
     }
-    
+
     public static  OnSubscribeFunc zip(Iterable> ws, final FuncN zipFunction) {
         ManyObservables a = new ManyObservables(ws, zipFunction);
         return a;
     }
-    
+
     /**
      * Merges the values across multiple sources and applies the selector
      * function.
@@ -115,18 +115,25 @@ public static  OnSubscribeFunc zip(Iterable> ws, f
      * only 1 item.
    
      * 
    Exception semantics: errors from the source observable are
      * propagated as-is.
    
-     * @param  the common element type
-     * @param  the result element type
+     * 
+     * @param 
+     *            the common element type
+     * @param 
+     *            the result element type
      */
     private static final class ManyObservables implements OnSubscribeFunc {
         /** */
         protected final Iterable> sources;
         /** */
         protected final FuncN selector;
+
         /**
          * Constructor.
-         * @param sources the sources
-         * @param selector the result selector
+         * 
+         * @param sources
+         *            the sources
+         * @param selector
+         *            the result selector
          */
         public ManyObservables(
                 Iterable> sources,
@@ -134,53 +141,58 @@ public ManyObservables(
             this.sources = sources;
             this.selector = selector;
         }
-        
+
         @Override
         public Subscription onSubscribe(final Observer observer) {
-            
+
             final CompositeSubscription composite = new CompositeSubscription();
-            
+
             final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
-            
+
             final List> all = new ArrayList>();
-            
+
             Observer> o2 = new Observer>() {
                 @Override
                 public void onCompleted() {
                     observer.onCompleted();
                 }
+
                 @Override
                 public void onError(Throwable t) {
                     observer.onError(t);
                 }
+
                 @Override
                 public void onNext(List value) {
                     observer.onNext(selector.call(value.toArray(new Object[value.size()])));
                 }
             };
-            
+
             for (Observable o : sources) {
-                
+
                 ItemObserver io = new ItemObserver(
                         rwLock, all, o, o2, composite);
                 composite.add(io);
                 all.add(io);
             }
-            
+
             for (ItemObserver io : all) {
                 io.connect();
             }
-            
+
             return composite;
         }
+
         /**
          * The individual line's observer.
+         * 
          * @author akarnokd, 2013.01.14.
-         * @param  the element type
+         * @param 
+         *            the element type
          */
         private static final class ItemObserver implements Observer, Subscription {
             /** Reader-writer lock. */
-            protected  final ReadWriteLock rwLock;
+            protected final ReadWriteLock rwLock;
             /** The queue. */
             public final Queue queue = new LinkedList();
             /** The list of the other observers. */
@@ -197,13 +209,20 @@ private static final class ItemObserver implements Observer, Subscription
             protected final Observable source;
             /** The observer. */
             protected final Observer> observer;
+
             /**
              * Constructor.
-             * @param rwLock the reader-writer lock to use
-             * @param all all observers
-             * @param source the source sequence
-             * @param observer the output observer
-             * @param cancel the cancellation handler
+             * 
+             * @param rwLock
+             *            the reader-writer lock to use
+             * @param all
+             *            all observers
+             * @param source
+             *            the source sequence
+             * @param observer
+             *            the output observer
+             * @param cancel
+             *            the cancellation handler
              */
             public ItemObserver(
                     ReadWriteLock rwLock,
@@ -217,6 +236,7 @@ public ItemObserver(
                 this.observer = observer;
                 this.cancel = cancel;
             }
+
             @SuppressWarnings("unchecked")
             @Override
             public void onNext(T value) {
@@ -247,7 +267,7 @@ public void onNext(T value) {
                                 if (v == NULL_SENTINEL) {
                                     v = null;
                                 }
-                                values.add((T)v);
+                                values.add((T) v);
                             }
                             if (values.size() == all.size()) {
                                 for (ItemObserver io : all) {
@@ -255,7 +275,7 @@ public void onNext(T value) {
                                 }
                                 observer.onNext(values);
                             } else {
-                            	break;
+                                break;
                             }
                         }
                     } finally {
@@ -263,7 +283,7 @@ public void onNext(T value) {
                     }
                 }
             }
-            
+
             @Override
             public void onError(Throwable ex) {
                 boolean c = false;
@@ -283,7 +303,7 @@ public void onError(Throwable ex) {
                     unsubscribe();
                 }
             }
-            
+
             @Override
             public void onCompleted() {
                 boolean c = false;
@@ -311,18 +331,20 @@ public void onCompleted() {
                     unsubscribe();
                 }
             }
+
             /** Connect to the source observable. */
             public void connect() {
                 toSource.setSubscription(source.subscribe(this));
             }
+
             @Override
             public void unsubscribe() {
                 toSource.unsubscribe();
             }
-            
+
         }
     }
-    
+
     /**
      * Zips an Observable and an iterable sequence and applies
      * a function to the pair of values.
@@ -330,7 +352,7 @@ public void unsubscribe() {
     public static  OnSubscribeFunc zipIterable(Observable source, Iterable other, Func2 zipFunction) {
         return new ZipIterable(source, other, zipFunction);
     }
-    
+
     /**
      * Zips an Observable and an iterable sequence and applies
      * a function to the pair of values.
@@ -348,7 +370,7 @@ public ZipIterable(Observable source, Iterable other,
 
         @Override
         public Subscription onSubscribe(Observer t1) {
-            
+
             Iterator it;
             boolean first;
             try {
@@ -359,22 +381,22 @@ public Subscription onSubscribe(Observer t1) {
                 return Subscriptions.empty();
             }
 
-            
             if (!first) {
                 t1.onCompleted();
                 return Subscriptions.empty();
             }
-            
+
             SerialSubscription ssub = new SerialSubscription();
-            
+
             ssub.set(source.subscribe(new SourceObserver(t1, it, zipFunction, ssub)));
-            
+
             return ssub;
         }
+
         /** Observe the source. */
         private static final class SourceObserver implements Observer {
             final Observer observer;
-            final Iterator other; 
+            final Iterator other;
             final Func2 zipFunction;
             final Subscription cancel;
 
@@ -389,7 +411,7 @@ public SourceObserver(Observer observer, Iterator other,
             @Override
             public void onNext(T args) {
                 U u = other.next();
-                
+
                 R r;
                 try {
                     r = zipFunction.call(args, u);
@@ -397,9 +419,9 @@ public void onNext(T args) {
                     onError(t);
                     return;
                 }
-                
+
                 observer.onNext(r);
-                
+
                 boolean has;
                 try {
                     has = other.hasNext();
@@ -407,7 +429,7 @@ public void onNext(T args) {
                     onError(t);
                     return;
                 }
-                
+
                 if (!has) {
                     onCompleted();
                 }
@@ -424,7 +446,7 @@ public void onCompleted() {
                 observer.onCompleted();
                 cancel.unsubscribe();
             }
-            
+
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
index 5ca9a81420..8ec7c301fc 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -39,8 +39,8 @@ public static RxJavaPlugins getInstance() {
     /* package accessible for unit tests */RxJavaPlugins() {
 
     }
-    
-    /* package accessible for ujnit tests */ void reset() {
+
+    /* package accessible for ujnit tests */void reset() {
         INSTANCE.errorHandler.set(null);
         INSTANCE.observableExecutionHook.set(null);
     }
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index 443056438b..cd619e24b7 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -159,10 +159,10 @@ private static class InnerExecutorScheduler extends Scheduler implements Subscri
 
         @Override
         public  Subscription schedule(T state, Func2 action) {
-            if(childSubscription.isUnsubscribed()) {
+            if (childSubscription.isUnsubscribed()) {
                 return childSubscription;
             }
-            
+
             CompositeSubscription s = new CompositeSubscription();
             final DiscardableAction discardableAction = new DiscardableAction(state, action);
             s.add(discardableAction);
@@ -194,10 +194,10 @@ public void run() {
 
         @Override
         public  Subscription schedule(final T state, final Func2 action, long delayTime, TimeUnit unit) {
-            if(childSubscription.isUnsubscribed()) {
+            if (childSubscription.isUnsubscribed()) {
                 return childSubscription;
             }
-            
+
             CompositeSubscription s = new CompositeSubscription();
             final DiscardableAction discardableAction = new DiscardableAction(state, action);
             s.add(discardableAction);
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 6247c3f54a..842881c1fa 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -98,7 +98,7 @@ public static Scheduler executor(ScheduledExecutorService executor) {
     public static Scheduler threadPoolForComputation() {
         return executor(COMPUTATION_EXECUTOR);
     }
-    
+
     /**
      * {@link Scheduler} intended for computational work.
      * 
    
@@ -128,7 +128,7 @@ public static Scheduler computation() {
     public static Scheduler threadPoolForIO() {
         return executor(IO_EXECUTOR);
     }
-    
+
     /**
      * {@link Scheduler} intended for IO-bound work.
      * 
    
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 69ddb7470b..22a00cc1c4 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -53,6 +53,7 @@ public final class ReplaySubject extends Subject {
     public static  ReplaySubject create() {
         return create(16);
     }
+
     public static  ReplaySubject create(int initialCapacity) {
         final SubjectSubscriptionManager subscriptionManager = new SubjectSubscriptionManager();
         final ReplayState state = new ReplayState(initialCapacity);
@@ -96,6 +97,7 @@ private static class ReplayState {
         final History history;
         // each Observer is tracked here for what events they have received
         final ConcurrentHashMap, Integer> replayState;
+
         public ReplayState(int initialCapacity) {
             history = new History(initialCapacity);
             replayState = new ConcurrentHashMap, Integer>();
@@ -206,11 +208,13 @@ private static class History {
         private final AtomicInteger index;
         private final ArrayList list;
         private final AtomicReference> terminalValue;
+
         public History(int initialCapacity) {
-             index = new AtomicInteger(0);
-             list = new ArrayList(initialCapacity);
-             terminalValue = new AtomicReference>();
+            index = new AtomicInteger(0);
+            list = new ArrayList(initialCapacity);
+            terminalValue = new AtomicReference>();
         }
+
         public boolean next(T n) {
             if (terminalValue.get() == null) {
                 list.add(n);
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index dfe6062a57..e1600197e6 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -125,15 +125,17 @@ protected void terminate(Action1>> onTermi
          */
         try {
             // had to circumvent type check, we know what the array contains
-            onTerminate.call((Collection)Arrays.asList(newState.observers));
+            onTerminate.call((Collection) Arrays.asList(newState.observers));
         } finally {
             // mark that termination is completed
             newState.terminationLatch.countDown();
         }
     }
+
     /**
      * Returns the array of observers directly.
      * Don't modify the array!
+     * 
      * @return the array of current observers
      */
     public SubjectObserver[] rawSnapshot() {
@@ -150,7 +152,8 @@ protected static class State {
         final Subscription[] EMPTY_S = new Subscription[0];
         // to avoid lots of empty arrays
         final SubjectObserver[] EMPTY_O = new SubjectObserver[0];
-        private State(boolean isTerminated, CountDownLatch terminationLatch, 
+
+        private State(boolean isTerminated, CountDownLatch terminationLatch,
                 Subscription[] subscriptions, SubjectObserver[] observers) {
             this.terminationLatch = terminationLatch;
             this.terminated = isTerminated;
@@ -174,15 +177,16 @@ public State terminate() {
 
         public State addObserver(Subscription s, SubjectObserver observer) {
             int n = this.observers.length;
-            
+
             Subscription[] newsubscriptions = Arrays.copyOf(this.subscriptions, n + 1);
             SubjectObserver[] newobservers = Arrays.copyOf(this.observers, n + 1);
-            
+
             newsubscriptions[n] = s;
             newobservers[n] = observer;
-            
+
             return createNewWith(newsubscriptions, newobservers);
         }
+
         private State createNewWith(Subscription[] newsubscriptions, SubjectObserver[] newobservers) {
             return new State(terminated, terminationLatch, newsubscriptions, newobservers);
         }
@@ -211,7 +215,7 @@ public State removeObserver(Subscription s) {
                     copied++;
                 }
             }
-            
+
             if (copied == 0) {
                 return createNewWith(EMPTY_S, EMPTY_O);
             }
diff --git a/rxjava-core/src/main/java/rx/util/CompositeException.java b/rxjava-core/src/main/java/rx/util/CompositeException.java
index c8534c9c11..f1eec78b6f 100644
--- a/rxjava-core/src/main/java/rx/util/CompositeException.java
+++ b/rxjava-core/src/main/java/rx/util/CompositeException.java
@@ -65,7 +65,8 @@ public synchronized Throwable getCause() {
         return cause;
     }
 
-    @SuppressWarnings("unused") // useful when debugging but don't want to make part of publicly supported API
+    @SuppressWarnings("unused")
+    // useful when debugging but don't want to make part of publicly supported API
     private static String getStackTraceAsString(StackTraceElement[] stack) {
         StringBuilder s = new StringBuilder();
         boolean firstLine = true;
diff --git a/rxjava-core/src/main/java/rx/util/functions/Actions.java b/rxjava-core/src/main/java/rx/util/functions/Actions.java
index 7a33d451ce..a315a1bfbb 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Actions.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Actions.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -21,12 +21,17 @@
  * Utility class for the Action interfaces.
  */
 public final class Actions {
-    private Actions() { throw new IllegalStateException("No instances!"); }
+    private Actions() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Extracts a method reference to the observer's onNext method
      * in the form of an Action1.
      * 
    Java 8: observer::onNext
    
-     * @param observer the observer to use
+     * 
+     * @param observer
+     *            the observer to use
      * @return an action which calls the observer's onNext method.
      */
     public static  Action1 onNextFrom(final Observer observer) {
@@ -37,11 +42,14 @@ public void call(T t1) {
             }
         };
     }
+
     /**
      * Extracts a method reference to the observer's onError method
      * in the form of an Action1.
      * 
    Java 8: observer::onError
    
-     * @param observer the observer to use
+     * 
+     * @param observer
+     *            the observer to use
      * @return an action which calls the observer's onError method.
      */
     public static  Action1 onErrorFrom(final Observer observer) {
@@ -52,11 +60,14 @@ public void call(Throwable t1) {
             }
         };
     }
+
     /**
      * Extracts a method reference to the observer's onCompleted method
      * in the form of an Action0.
      * 
    Java 8: observer::onCompleted
    
-     * @param observer the observer to use
+     * 
+     * @param observer
+     *            the observer to use
      * @return an action which calls the observer's onCompleted method.
      */
     public static  Action0 onCompletedFrom(final Observer observer) {
@@ -67,114 +78,138 @@ public void call() {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static Func0 toFunc(final Action0 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func1 toFunc(final Action1 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func2 toFunc(final Action2 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func3 toFunc(final Action3 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func4 toFunc(final Action4 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func5 toFunc(
             final Action5 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func6 toFunc(
             final Action6 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func7 toFunc(
             final Action7 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func8 toFunc(
             final Action8 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static  Func9 toFunc(
             final Action9 action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @return {@link Func0}
      */
     public static FuncN toFunc(
             final ActionN action) {
-        return toFunc(action, (Void)null);
+        return toFunc(action, (Void) null);
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns the given result.
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -188,9 +223,11 @@ public R call() {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -204,9 +241,11 @@ public R call(T1 t1) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -220,9 +259,11 @@ public R call(T1 t1, T2 t2) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -236,9 +277,11 @@ public R call(T1 t1, T2 t2, T3 t3) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -252,9 +295,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -269,9 +314,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -286,9 +333,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -303,9 +352,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -320,9 +371,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
@@ -337,9 +390,11 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
             }
         };
     }
+
     /**
      * Convert an action to a function which calls
      * the action returns Void (null).
+     * 
      * @param action
      * @param result
      * @return {@link Func0}
diff --git a/rxjava-core/src/test/java/rx/CombineLatestTests.java b/rxjava-core/src/test/java/rx/CombineLatestTests.java
index c52daa3870..17f1a1b9ad 100644
--- a/rxjava-core/src/test/java/rx/CombineLatestTests.java
+++ b/rxjava-core/src/test/java/rx/CombineLatestTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ConcatTests.java b/rxjava-core/src/test/java/rx/ConcatTests.java
index 80f7eb5ef7..8a59eaee29 100644
--- a/rxjava-core/src/test/java/rx/ConcatTests.java
+++ b/rxjava-core/src/test/java/rx/ConcatTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/CovarianceTest.java b/rxjava-core/src/test/java/rx/CovarianceTest.java
index 48ca64f61e..1b19d6abcd 100644
--- a/rxjava-core/src/test/java/rx/CovarianceTest.java
+++ b/rxjava-core/src/test/java/rx/CovarianceTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java
index f41e670923..257a7a543b 100644
--- a/rxjava-core/src/test/java/rx/EventStream.java
+++ b/rxjava-core/src/test/java/rx/EventStream.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/GroupByTests.java b/rxjava-core/src/test/java/rx/GroupByTests.java
index de3310b35c..05467739ec 100644
--- a/rxjava-core/src/test/java/rx/GroupByTests.java
+++ b/rxjava-core/src/test/java/rx/GroupByTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/IntervalDemo.java b/rxjava-core/src/test/java/rx/IntervalDemo.java
index 0222bc1b55..ee4f02cbb3 100644
--- a/rxjava-core/src/test/java/rx/IntervalDemo.java
+++ b/rxjava-core/src/test/java/rx/IntervalDemo.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/MergeTests.java b/rxjava-core/src/test/java/rx/MergeTests.java
index 1f697ce46a..b2140b3750 100644
--- a/rxjava-core/src/test/java/rx/MergeTests.java
+++ b/rxjava-core/src/test/java/rx/MergeTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index fb3b95e7db..d2b0b3fd26 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -33,18 +33,14 @@
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
 
 import rx.Observable.OnSubscribeFunc;
 import rx.observables.ConnectableObservable;
-import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
-import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
@@ -236,7 +232,6 @@ public Integer call(Integer t1, Integer t2) {
         verify(w).onNext(10);
     }
 
-    
     /**
      * A reduce should fail with an IllegalArgumentException if done on an empty Observable.
      */
@@ -260,7 +255,7 @@ public void call(Integer t1) {
 
         fail("Expected an exception to be thrown");
     }
-    
+
     /**
      * A reduce on an empty Observable and a seed should just pass the seed through.
      * 
@@ -280,7 +275,7 @@ public Integer call(Integer t1, Integer t2) {
 
         assertEquals(1, value);
     }
-    
+
     @Test
     public void testReduceWithInitialValue() {
         Observable observable = Observable.from(1, 2, 3, 4);
@@ -969,7 +964,7 @@ public void testRangeWithScheduler() {
         inOrder.verify(aObserver, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void testCollectToList() {
         List list = Observable.from(1, 2, 3).collect(new ArrayList(), new Action2, Integer>() {
diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
index 855e108312..63ea714d05 100644
--- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -44,7 +44,7 @@ public void call(List xs) {
             }
         });
 
-        assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[]{1, 2, 3});
+        assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[] { 1, 2, 3 });
         assertArrayEquals(lists.get(1).toArray(new Integer[3]), new Integer[] { 4, 5, 6 });
         assertEquals(2, lists.size());
 
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 08ff57405b..bad2f8881b 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index 3f02933a80..ed30de87c5 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ScanTests.java b/rxjava-core/src/test/java/rx/ScanTests.java
index d7948963d7..f6b7fd2b04 100644
--- a/rxjava-core/src/test/java/rx/ScanTests.java
+++ b/rxjava-core/src/test/java/rx/ScanTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/StartWithTests.java b/rxjava-core/src/test/java/rx/StartWithTests.java
index 5bf3c518c2..4b5185bb6f 100644
--- a/rxjava-core/src/test/java/rx/StartWithTests.java
+++ b/rxjava-core/src/test/java/rx/StartWithTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
index bbba421477..e8df39ce7a 100644
--- a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ThrottleLastTests.java b/rxjava-core/src/test/java/rx/ThrottleLastTests.java
index 94ec7051b2..3bc7b13e7e 100644
--- a/rxjava-core/src/test/java/rx/ThrottleLastTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleLastTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
index 2e27c81cce..4e9220724e 100644
--- a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/TimeoutTests.java b/rxjava-core/src/test/java/rx/TimeoutTests.java
index 144824d222..4ee1947b7e 100644
--- a/rxjava-core/src/test/java/rx/TimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/TimeoutTests.java
@@ -15,12 +15,8 @@
  */
 package rx;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index dd406ee2e0..97172af719 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
index 7fd8471683..16a63450fe 100644
--- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -19,8 +19,8 @@
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import org.junit.Assert;
 
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
@@ -203,29 +203,30 @@ public void testToIterable() {
         assertEquals(false, it.hasNext());
 
     }
+
     @Test(expected = NoSuchElementException.class)
     public void testToIterableNextOnly() {
         BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3));
 
         Iterator it = obs.toIterable().iterator();
-        
-        Assert.assertEquals((Integer)1, it.next());
-        Assert.assertEquals((Integer)2, it.next());
-        Assert.assertEquals((Integer)3, it.next());
-        
+
+        Assert.assertEquals((Integer) 1, it.next());
+        Assert.assertEquals((Integer) 2, it.next());
+        Assert.assertEquals((Integer) 3, it.next());
+
         it.next();
     }
-    
+
     @Test(expected = NoSuchElementException.class)
     public void testToIterableNextOnlyTwice() {
         BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3));
 
         Iterator it = obs.toIterable().iterator();
-        
-        Assert.assertEquals((Integer)1, it.next());
-        Assert.assertEquals((Integer)2, it.next());
-        Assert.assertEquals((Integer)3, it.next());
-        
+
+        Assert.assertEquals((Integer) 1, it.next());
+        Assert.assertEquals((Integer) 2, it.next());
+        Assert.assertEquals((Integer) 3, it.next());
+
         boolean exc = false;
         try {
             it.next();
@@ -233,25 +234,25 @@ public void testToIterableNextOnlyTwice() {
             exc = true;
         }
         Assert.assertEquals(true, exc);
-        
+
         it.next();
     }
-    
+
     @Test
     public void testToIterableManyTimes() {
         BlockingObservable obs = BlockingObservable.from(Observable.from(1, 2, 3));
-        
+
         Iterable iter = obs.toIterable();
-        
+
         for (int j = 0; j < 3; j++) {
             Iterator it = iter.iterator();
-            
+
             Assert.assertTrue(it.hasNext());
-            Assert.assertEquals((Integer)1, it.next());
+            Assert.assertEquals((Integer) 1, it.next());
             Assert.assertTrue(it.hasNext());
-            Assert.assertEquals((Integer)2, it.next());
+            Assert.assertEquals((Integer) 2, it.next());
             Assert.assertTrue(it.hasNext());
-            Assert.assertEquals((Integer)3, it.next());
+            Assert.assertEquals((Integer) 3, it.next());
             Assert.assertFalse(it.hasNext());
         }
     }
@@ -319,7 +320,7 @@ public void testFirst() {
 
     @Test(expected = IllegalArgumentException.class)
     public void testFirstWithEmpty() {
-        BlockingObservable.from(Observable.empty()).first();
+        BlockingObservable.from(Observable. empty()).first();
     }
 
     @Test
@@ -353,7 +354,7 @@ public void testFirstOrDefault() {
 
     @Test
     public void testFirstOrDefaultWithEmpty() {
-        BlockingObservable observable = BlockingObservable.from(Observable.empty());
+        BlockingObservable observable = BlockingObservable.from(Observable. empty());
         assertEquals("default", observable.firstOrDefault("default"));
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
index 0b05ee1d4e..c04e11a8fc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
index f98149376a..b300f9909a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
index c0d7ac9366..babf6ea523 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationAverage.*;
 
@@ -119,17 +120,19 @@ public void testEmptyAverageDoubles() throws Throwable {
         verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
         verify(wd, never()).onCompleted();
     }
-    
+
     void testThrows(Observer o, Class errorClass) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o, times(1)).onError(any(errorClass));
     }
+
      void testValue(Observer o, N value) {
         verify(o, times(1)).onNext(value);
         verify(o, times(1)).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testIntegerAverageSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
@@ -139,61 +142,65 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        
+
         Observable result = source.averageInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 2);
     }
+
     @Test
     public void testLongAverageSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Long call(String t1) {
-                return (long)t1.length();
+                return (long) t1.length();
             }
         };
-        
+
         Observable result = source.averageLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 2L);
     }
+
     @Test
     public void testFloatAverageSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Float call(String t1) {
-                return (float)t1.length();
+                return (float) t1.length();
             }
         };
-        
+
         Observable result = source.averageFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 2.5f);
     }
+
     @Test
     public void testDoubleAverageSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Double call(String t1) {
-                return (double)t1.length();
+                return (double) t1.length();
             }
         };
-        
+
         Observable result = source.averageDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 2.5d);
     }
+
     @Test
     public void testIntegerAverageSelectorEmpty() {
         Observable source = Observable.empty();
@@ -203,61 +210,65 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        
+
         Observable result = source.averageInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testLongAverageSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Long call(String t1) {
-                return (long)t1.length();
+                return (long) t1.length();
             }
         };
-        
+
         Observable result = source.averageLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testFloatAverageSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Float call(String t1) {
-                return (float)t1.length();
+                return (float) t1.length();
             }
         };
-        
+
         Observable result = source.averageFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testDoubleAverageSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Double call(String t1) {
-                return (double)t1.length();
+                return (double) t1.length();
             }
         };
-        
+
         Observable result = source.averageDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testIntegerAverageSelectorThrows() {
         Observable source = Observable.from("a");
@@ -267,13 +278,14 @@ public Integer call(String t1) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = source.averageInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, CustomException.class);
     }
+
     @Test
     public void testLongAverageSelectorThrows() {
         Observable source = Observable.from("a");
@@ -283,13 +295,14 @@ public Long call(String t1) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = source.averageLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, CustomException.class);
     }
+
     @Test
     public void testFloatAverageSelectorThrows() {
         Observable source = Observable.from("a");
@@ -299,13 +312,14 @@ public Float call(String t1) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = source.averageFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, CustomException.class);
     }
+
     @Test
     public void testDoubleAverageSelectorThrows() {
         Observable source = Observable.from("a");
@@ -315,11 +329,11 @@ public Double call(String t1) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = source.averageDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, CustomException.class);
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index eb9a4fee5d..2f3c1ddc2e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -16,6 +16,8 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 import static rx.operators.OperationBuffer.*;
 
 import java.util.ArrayList;
@@ -28,7 +30,6 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
-import static org.mockito.Mockito.*;
 
 import rx.Observable;
 import rx.Observer;
@@ -362,152 +363,155 @@ public void call() {
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
-    
+
     @Test
     public void testBufferStopsWhenUnsubscribed1() {
         Observable source = Observable.never();
-        
+
         Observer> o = mock(Observer.class);
-        
+
         Subscription s = source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler).subscribe(o);
-        
+
         InOrder inOrder = Mockito.inOrder(o);
-        
+
         scheduler.advanceTimeBy(1001, TimeUnit.MILLISECONDS);
-        
-        inOrder.verify(o, times(5)).onNext(Arrays.asList());
-        
+
+        inOrder.verify(o, times(5)).onNext(Arrays. asList());
+
         s.unsubscribe();
 
         scheduler.advanceTimeBy(999, TimeUnit.MILLISECONDS);
-        
+
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void bufferWithBONormal1() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = Mockito.inOrder(o);
-        
+
         source.buffer(boundary).subscribe(o);
 
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         boundary.onNext(1);
 
         inOrder.verify(o, times(1)).onNext(Arrays.asList(1, 2, 3));
 
         source.onNext(4);
         source.onNext(5);
-        
+
         boundary.onNext(2);
-        
+
         inOrder.verify(o, times(1)).onNext(Arrays.asList(4, 5));
 
         source.onNext(6);
         boundary.onCompleted();
-        
+
         inOrder.verify(o, times(1)).onNext(Arrays.asList(6));
-        
+
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void bufferWithBOEmptyLastViaBoundary() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = Mockito.inOrder(o);
-        
+
         source.buffer(boundary).subscribe(o);
-        
+
         boundary.onCompleted();
-        
+
         inOrder.verify(o, times(1)).onNext(Arrays.asList());
-        
+
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void bufferWithBOEmptyLastViaSource() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = Mockito.inOrder(o);
-        
+
         source.buffer(boundary).subscribe(o);
-        
+
         source.onCompleted();
-        
+
         inOrder.verify(o, times(1)).onNext(Arrays.asList());
-        
+
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void bufferWithBOEmptyLastViaBoth() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = Mockito.inOrder(o);
-        
+
         source.buffer(boundary).subscribe(o);
-        
+
         source.onCompleted();
         boundary.onCompleted();
-        
+
         inOrder.verify(o, times(1)).onNext(Arrays.asList());
-        
+
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void bufferWithBOSourceThrows() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
 
         source.buffer(boundary).subscribe(o);
         source.onNext(1);
         source.onError(new OperationReduceTest.CustomException());
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
     }
-    
+
     @Test
     public void bufferWithBOBoundaryThrows() {
         PublishSubject source = PublishSubject.create();
         PublishSubject boundary = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
 
         source.buffer(boundary).subscribe(o);
-        
+
         source.onNext(1);
         boundary.onError(new OperationReduceTest.CustomException());
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
index 79a811b6de..7a373066c0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCastTest.java b/rxjava-core/src/test/java/rx/operators/OperationCastTest.java
index 782fe6bc90..fff46810b8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCastTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
index 70d34bd887..f40b86e311 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -175,7 +175,6 @@ public void testCombineLatestWithInterleavingSequences() {
         inOrder.verify(w, times(1)).onCompleted();
     }
 
-    
     @SuppressWarnings("unchecked")
     /* mock calls don't do generics */
     @Test
@@ -330,144 +329,145 @@ public Integer call(Integer t1, Integer t2) {
     public void combineSimple() {
         PublishSubject a = PublishSubject.create();
         PublishSubject b = PublishSubject.create();
-        
+
         Observable source = Observable.combineLatest(a, b, or);
-        
+
         Observer observer = mock(Observer.class);
-        
+
         source.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         a.onNext(1);
-        
+
         inOrder.verify(observer, never()).onNext(any());
-        
+
         a.onNext(2);
-        
+
         inOrder.verify(observer, never()).onNext(any());
-        
+
         b.onNext(0x10);
-        
+
         inOrder.verify(observer, times(1)).onNext(0x12);
-        
+
         b.onNext(0x20);
         inOrder.verify(observer, times(1)).onNext(0x22);
-        
+
         b.onCompleted();
-        
+
         inOrder.verify(observer, never()).onCompleted();
-        
+
         a.onCompleted();
 
         inOrder.verify(observer, times(1)).onCompleted();
-        
+
         a.onNext(3);
         b.onNext(0x30);
         a.onCompleted();
         b.onCompleted();
-        
+
         inOrder.verifyNoMoreInteractions();
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void combineMultipleObservers() {
         PublishSubject a = PublishSubject.create();
         PublishSubject b = PublishSubject.create();
-        
+
         Observable source = Observable.combineLatest(a, b, or);
-        
+
         Observer observer1 = mock(Observer.class);
         Observer observer2 = mock(Observer.class);
-        
+
         source.subscribe(observer1);
         source.subscribe(observer2);
-        
+
         InOrder inOrder1 = inOrder(observer1);
         InOrder inOrder2 = inOrder(observer2);
-        
+
         a.onNext(1);
-        
+
         inOrder1.verify(observer1, never()).onNext(any());
         inOrder2.verify(observer2, never()).onNext(any());
-        
+
         a.onNext(2);
-        
+
         inOrder1.verify(observer1, never()).onNext(any());
         inOrder2.verify(observer2, never()).onNext(any());
-        
+
         b.onNext(0x10);
-        
+
         inOrder1.verify(observer1, times(1)).onNext(0x12);
         inOrder2.verify(observer2, times(1)).onNext(0x12);
-        
+
         b.onNext(0x20);
         inOrder1.verify(observer1, times(1)).onNext(0x22);
         inOrder2.verify(observer2, times(1)).onNext(0x22);
-        
+
         b.onCompleted();
-        
+
         inOrder1.verify(observer1, never()).onCompleted();
         inOrder2.verify(observer2, never()).onCompleted();
-        
+
         a.onCompleted();
 
         inOrder1.verify(observer1, times(1)).onCompleted();
         inOrder2.verify(observer2, times(1)).onCompleted();
-        
+
         a.onNext(3);
         b.onNext(0x30);
         a.onCompleted();
         b.onCompleted();
-        
+
         inOrder1.verifyNoMoreInteractions();
         inOrder2.verifyNoMoreInteractions();
         verify(observer1, never()).onError(any(Throwable.class));
         verify(observer2, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testFirstNeverProduces() {
         PublishSubject a = PublishSubject.create();
         PublishSubject b = PublishSubject.create();
-        
+
         Observable source = Observable.combineLatest(a, b, or);
-        
+
         Observer observer = mock(Observer.class);
-        
+
         source.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         b.onNext(0x10);
         b.onNext(0x20);
-        
+
         a.onCompleted();
-        
+
         inOrder.verify(observer, times(1)).onCompleted();
         verify(observer, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testSecondNeverProduces() {
         PublishSubject a = PublishSubject.create();
         PublishSubject b = PublishSubject.create();
-        
+
         Observable source = Observable.combineLatest(a, b, or);
-        
+
         Observer observer = mock(Observer.class);
-        
+
         source.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         a.onNext(0x1);
         a.onNext(0x2);
-        
+
         b.onCompleted();
         a.onCompleted();
-        
+
         inOrder.verify(observer, times(1)).onCompleted();
         verify(observer, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
index 05117231dc..f347182f7e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationConcat.*;
 
@@ -553,24 +554,25 @@ void waitForThreadDone() throws InterruptedException {
             t.join();
         }
     }
+
     @Test
     public void testMultipleObservers() {
         Observer o1 = mock(Observer.class);
         Observer o2 = mock(Observer.class);
-        
+
         TestScheduler s = new TestScheduler();
-        
+
         Observable timer = Observable.interval(500, TimeUnit.MILLISECONDS, s).take(2);
         Observable o = Observable.concat(timer, timer);
-        
+
         o.subscribe(o1);
         o.subscribe(o2);
-        
+
         InOrder inOrder1 = inOrder(o1);
         InOrder inOrder2 = inOrder(o2);
 
         s.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         inOrder1.verify(o1, times(1)).onNext(0L);
         inOrder2.verify(o2, times(1)).onNext(0L);
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index 02f5ccde0a..65d555c571 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
@@ -159,7 +160,7 @@ public void call() {
     @SuppressWarnings("serial")
     private class TestException extends Exception {
     }
-    
+
     @Test
     public void debounceSelectorNormal1() {
         PublishSubject source = PublishSubject.create();
@@ -171,33 +172,33 @@ public Observable call(Integer t1) {
                 return debouncer;
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.debounce(debounceSel).subscribe(o);
-        
+
         source.onNext(1);
         debouncer.onNext(1);
-        
+
         source.onNext(2);
         source.onNext(3);
         source.onNext(4);
 
         debouncer.onNext(2);
-        
+
         source.onNext(5);
         source.onCompleted();
-        
+
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(4);
         inOrder.verify(o).onNext(5);
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void debounceSelectorFuncThrows() {
         PublishSubject source = PublishSubject.create();
@@ -208,19 +209,19 @@ public Observable call(Integer t1) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.debounce(debounceSel).subscribe(o);
-        
+
         source.onNext(1);
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
-    
+
     @Test
     public void debounceSelectorObservableThrows() {
         PublishSubject source = PublishSubject.create();
@@ -231,14 +232,14 @@ public Observable call(Integer t1) {
                 return Observable.error(new OperationReduceTest.CustomException());
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.debounce(debounceSel).subscribe(o);
-        
+
         source.onNext(1);
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java b/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
index 68003ceb01..1b53d500a6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
index 550f428134..b757a7b678 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
index 81728753c6..6affc04b46 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,16 +15,12 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static org.mockito.MockitoAnnotations.*;
+
 import java.util.ArrayList;
 import java.util.List;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Before;
@@ -32,7 +28,6 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.mock;
 
 import rx.Observable;
 import rx.Observer;
@@ -55,19 +50,19 @@ public void before() {
         initMocks(this);
         scheduler = new TestScheduler();
     }
-    
+
     @Test
     public void testDelay() {
         Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3);
         Observable delayed = source.delay(500L, TimeUnit.MILLISECONDS, scheduler);
         delayed.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
         scheduler.advanceTimeTo(1499L, TimeUnit.MILLISECONDS);
         verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
         scheduler.advanceTimeTo(1500L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(0L);
         inOrder.verify(observer, never()).onNext(anyLong());
@@ -78,13 +73,13 @@ public void testDelay() {
         inOrder.verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
         scheduler.advanceTimeTo(2500L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(1L);
         inOrder.verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
         scheduler.advanceTimeTo(3400L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
@@ -101,14 +96,14 @@ public void testLongDelay() {
         Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3);
         Observable delayed = source.delay(5L, TimeUnit.SECONDS, scheduler);
         delayed.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         scheduler.advanceTimeTo(5999L, TimeUnit.MILLISECONDS);
         verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
         scheduler.advanceTimeTo(6000L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(0L);
         scheduler.advanceTimeTo(6999L, TimeUnit.MILLISECONDS);
@@ -124,7 +119,7 @@ public void testLongDelay() {
         inOrder.verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testDelayWithError() {
         Observable source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).map(new Func1() {
@@ -133,30 +128,30 @@ public Long call(Long value) {
                 if (value == 1L) {
                     throw new RuntimeException("error!");
                 }
-                return value; 
+                return value;
             }
         });
         Observable delayed = source.delay(1L, TimeUnit.SECONDS, scheduler);
         delayed.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
-        
+
         scheduler.advanceTimeTo(1999L, TimeUnit.MILLISECONDS);
         verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
         scheduler.advanceTimeTo(2000L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onError(any(Throwable.class));
         inOrder.verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
-        
+
         scheduler.advanceTimeTo(5000L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, never()).onNext(anyLong());
         inOrder.verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
-    
+
     // TODO activate this test once https://github.com/Netflix/RxJava/issues/552 is fixed
     @Ignore
     @Test
@@ -165,10 +160,10 @@ public void testDelayWithMultipleSubscriptions() {
         Observable delayed = source.delay(500L, TimeUnit.MILLISECONDS, scheduler);
         delayed.subscribe(observer);
         delayed.subscribe(observer2);
-        
+
         InOrder inOrder = inOrder(observer);
         InOrder inOrder2 = inOrder(observer2);
-        
+
         scheduler.advanceTimeTo(1499L, TimeUnit.MILLISECONDS);
         verify(observer, never()).onNext(anyLong());
         verify(observer2, never()).onNext(anyLong());
@@ -180,7 +175,7 @@ public void testDelayWithMultipleSubscriptions() {
         scheduler.advanceTimeTo(2499L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, never()).onNext(anyLong());
         inOrder2.verify(observer2, never()).onNext(anyLong());
-        
+
         scheduler.advanceTimeTo(2500L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(1L);
         inOrder2.verify(observer2, times(1)).onNext(1L);
@@ -199,18 +194,18 @@ public void testDelayWithMultipleSubscriptions() {
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer2, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testDelaySubscription() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         Observable result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         inOrder.verify(o, never()).onNext(any());
         inOrder.verify(o, never()).onCompleted();
 
@@ -220,17 +215,18 @@ public void testDelaySubscription() {
         inOrder.verify(o, times(1)).onNext(2);
         inOrder.verify(o, times(1)).onNext(3);
         inOrder.verify(o, times(1)).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testDelaySubscriptionCancelBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         Observable result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         Subscription s = result.subscribe(o);
         s.unsubscribe();
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
@@ -239,7 +235,7 @@ public void testDelaySubscriptionCancelBeforeTime() {
         verify(o, never()).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testDelayWithObservableNormal1() {
         PublishSubject source = PublishSubject.create();
@@ -256,27 +252,26 @@ public Observable call(Integer t1) {
                 return delays.get(t1);
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.delay(delayFunc).subscribe(o);
-        
-        
+
         for (int i = 0; i < n; i++) {
             source.onNext(i);
             delays.get(i).onNext(i);
             inOrder.verify(o).onNext(i);
         }
         source.onCompleted();
-        
+
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testDelayWithObservableSingleSend1() {
         PublishSubject source = PublishSubject.create();
@@ -294,15 +289,16 @@ public Observable call(Integer t1) {
         InOrder inOrder = inOrder(o);
 
         source.delay(delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         delay.onNext(1);
         delay.onNext(2);
-        
+
         inOrder.verify(o).onNext(1);
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testDelayWithObservableSourceThrows() {
         PublishSubject source = PublishSubject.create();
@@ -329,6 +325,7 @@ public Observable call(Integer t1) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testDelayWithObservableDelayFunctionThrows() {
         PublishSubject source = PublishSubject.create();
@@ -352,7 +349,7 @@ public Observable call(Integer t1) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
-    
+
     @Test
     public void testDelayWithObservableDelayThrows() {
         PublishSubject source = PublishSubject.create();
@@ -378,6 +375,7 @@ public Observable call(Integer t1) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testDelayWithObservableSubscriptionNormal() {
         PublishSubject source = PublishSubject.create();
@@ -395,24 +393,25 @@ public Observable call(Integer t1) {
                 return delay;
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
         source.delay(subFunc, delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         delay.onNext(1);
 
         source.onNext(2);
         delay.onNext(2);
-        
+
         inOrder.verify(o).onNext(2);
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onError(any(Throwable.class));
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testDelayWithObservableSubscriptionFunctionThrows() {
         PublishSubject source = PublishSubject.create();
@@ -430,23 +429,24 @@ public Observable call(Integer t1) {
                 return delay;
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
         source.delay(subFunc, delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         delay.onNext(1);
 
         source.onNext(2);
-        
+
         inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testDelayWithObservableSubscriptionThrows() {
         PublishSubject source = PublishSubject.create();
@@ -464,23 +464,24 @@ public Observable call(Integer t1) {
                 return delay;
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
         source.delay(subFunc, delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         delay.onError(new OperationReduceTest.CustomException());
 
         source.onNext(2);
-        
+
         inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testDelayWithObservableEmptyDelayer() {
         PublishSubject source = PublishSubject.create();
@@ -497,16 +498,16 @@ public Observable call(Integer t1) {
         InOrder inOrder = inOrder(o);
 
         source.delay(delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         source.onCompleted();
-        
+
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testDelayWithObservableSubscriptionRunCompletion() {
         PublishSubject source = PublishSubject.create();
@@ -525,19 +526,19 @@ public Observable call(Integer t1) {
                 return delay;
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
         source.delay(subFunc, delayFunc).subscribe(o);
-        
+
         source.onNext(1);
         sdelay.onCompleted();
 
         source.onNext(2);
         delay.onNext(2);
-        
+
         inOrder.verify(o).onNext(2);
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onError(any(Throwable.class));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
index 1465b4f3d2..165f9b92c8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
index de57e8fc1e..634fc20d58 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
index b4568baaf7..55ea0a13c2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
index a902312ba1..b2a89972c5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDoOnEachTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,28 +15,18 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationMap.*;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
 import rx.Observer;
-import rx.schedulers.Schedulers;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 
 public class OperationDoOnEachTest {
 
@@ -52,7 +42,7 @@ public void before() {
 
     @Test
     public void testDoOnEach() {
-        Observable base     = Observable.from("a", "b", "c");
+        Observable base = Observable.from("a", "b", "c");
         Observable doOnEach = base.doOnEach(sideEffectObserver);
 
         doOnEach.subscribe(subscribedObserver);
@@ -71,8 +61,6 @@ public void testDoOnEach() {
         verify(sideEffectObserver, times(1)).onNext("c");
         verify(sideEffectObserver, times(1)).onCompleted();
     }
-    
-
 
     @Test
     public void testDoOnEachWithError() {
@@ -86,9 +74,8 @@ public String call(String s) {
                 return s;
             }
         });
-        
-        Observable doOnEach = errs.doOnEach(sideEffectObserver);
 
+        Observable doOnEach = errs.doOnEach(sideEffectObserver);
 
         doOnEach.subscribe(subscribedObserver);
         verify(subscribedObserver, times(1)).onNext("one");
@@ -97,7 +84,6 @@ public String call(String s) {
         verify(subscribedObserver, never()).onCompleted();
         verify(subscribedObserver, times(1)).onError(any(Throwable.class));
 
-
         verify(sideEffectObserver, times(1)).onNext("one");
         verify(sideEffectObserver, never()).onNext("two");
         verify(sideEffectObserver, never()).onNext("three");
@@ -107,7 +93,7 @@ public String call(String s) {
 
     @Test
     public void testDoOnEachWithErrorInCallback() {
-        Observable base     = Observable.from("one", "two", "fail", "three");
+        Observable base = Observable.from("one", "two", "fail", "three");
         Observable doOnEach = base.doOnNext(new Action1() {
             @Override
             public void call(String s) {
@@ -125,5 +111,5 @@ public void call(String s) {
         verify(subscribedObserver, times(1)).onError(any(Throwable.class));
 
     }
-  
+
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java b/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
index a28de23d08..696a8b01a4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java b/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java
index c22c3d46b8..8272d0eddb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
index 1ce2111fe9..f638e52eea 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
index dfa4de615f..eafd02ecdf 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
index f081f0f8e8..0e5ce2a7b8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.Arrays;
 import java.util.List;
+
 import org.junit.Test;
-import static org.mockito.Mockito.*;
+
 import rx.Observable;
 import rx.Observer;
 import rx.util.functions.Func0;
@@ -32,7 +36,7 @@ public void testNormal() {
         Observer o = mock(Observer.class);
 
         final List list = Arrays.asList(1, 2, 3);
-        
+
         Func1> func = new Func1>() {
             @Override
             public List call(Integer t1) {
@@ -46,9 +50,9 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 | t2;
             }
         };
-        
+
         List source = Arrays.asList(16, 32, 64);
-        
+
         Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
 
         for (Integer s : source) {
@@ -59,6 +63,7 @@ public Integer call(Integer t1, Integer t2) {
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testCollectionFunctionThrows() {
         @SuppressWarnings("unchecked")
@@ -77,23 +82,23 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 | t2;
             }
         };
-        
+
         List source = Arrays.asList(16, 32, 64);
-        
+
         Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
-        
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
-    
+
     @Test
     public void testResultFunctionThrows() {
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
 
         final List list = Arrays.asList(1, 2, 3);
-        
+
         Func1> func = new Func1>() {
             @Override
             public List call(Integer t1) {
@@ -107,15 +112,16 @@ public Integer call(Integer t1, Integer t2) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         List source = Arrays.asList(16, 32, 64);
-        
+
         Observable.from(source).mergeMapIterable(func, resFunc).subscribe(o);
-        
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
+
     @Test
     public void testMergeError() {
         @SuppressWarnings("unchecked")
@@ -134,15 +140,16 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 | t2;
             }
         };
-        
+
         List source = Arrays.asList(16, 32, 64);
-        
+
         Observable.from(source).mergeMap(func, resFunc).subscribe(o);
-        
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
+
      Func1 just(final R value) {
         return new Func1() {
 
@@ -152,6 +159,7 @@ public R call(T t1) {
             }
         };
     }
+
      Func0 just0(final R value) {
         return new Func0() {
 
@@ -161,53 +169,56 @@ public R call() {
             }
         };
     }
+
     @Test
     public void testFlatMapTransformsNormal() {
         Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
+
         Observable source = Observable.from(Arrays.asList(10, 20, 30));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.mergeMap(just(onNext), just(onError), just0(onCompleted)).subscribe(o);
-        
+
         verify(o, times(3)).onNext(1);
         verify(o, times(3)).onNext(2);
         verify(o, times(3)).onNext(3);
         verify(o).onNext(4);
         verify(o).onCompleted();
-        
+
         verify(o, never()).onNext(5);
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testFlatMapTransformsException() {
         Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
+
         Observable source = Observable.concat(
                 Observable.from(Arrays.asList(10, 20, 30))
-                , Observable.error(new RuntimeException("Forced failure!"))
+                , Observable. error(new RuntimeException("Forced failure!"))
                 );
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.mergeMap(just(onNext), just(onError), just0(onCompleted)).subscribe(o);
-        
+
         verify(o, times(3)).onNext(1);
         verify(o, times(3)).onNext(2);
         verify(o, times(3)).onNext(3);
         verify(o).onNext(5);
         verify(o).onCompleted();
         verify(o, never()).onNext(4);
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
      Func0 funcThrow0(R r) {
         return new Func0() {
             @Override
@@ -216,6 +227,7 @@ public R call() {
             }
         };
     }
+
      Func1 funcThrow(T t, R r) {
         return new Func1() {
             @Override
@@ -224,70 +236,73 @@ public R call(T t) {
             }
         };
     }
+
     @Test
     public void testFlatMapTransformsOnNextFuncThrows() {
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
+
         Observable source = Observable.from(Arrays.asList(10, 20, 30));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.mergeMap(funcThrow(1, onError), just(onError), just0(onCompleted)).subscribe(o);
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testFlatMapTransformsOnErrorFuncThrows() {
         Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
+
         Observable source = Observable.error(new OperationReduceTest.CustomException());
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
-        source.mergeMap(just(onNext), funcThrow((Throwable)null, onError), just0(onCompleted)).subscribe(o);
-        
+
+        source.mergeMap(just(onNext), funcThrow((Throwable) null, onError), just0(onCompleted)).subscribe(o);
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
-    
+
     @Test
     public void testFlatMapTransformsOnCompletedFuncThrows() {
         Observable onNext = Observable.from(Arrays.asList(1, 2, 3));
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
-        Observable source = Observable.from(Arrays.asList());
-        
+
+        Observable source = Observable.from(Arrays. asList());
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
-    @Test 
+
+    @Test
     public void testFlatMapTransformsMergeException() {
         Observable onNext = Observable.error(new OperationReduceTest.CustomException());
         Observable onCompleted = Observable.from(Arrays.asList(4));
         Observable onError = Observable.from(Arrays.asList(5));
-        
+
         Observable source = Observable.from(Arrays.asList(10, 20, 30));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupByTest.java
index cf47d9e683..29424fb0ba 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupByTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
index ca04ba70cd..d4fea3fe80 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
@@ -1,31 +1,36 @@
- /**
-  * 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.
-  */
+/**
+ * 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 static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
+
 import junit.framework.Assert;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.*;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.observables.GroupedObservable;
@@ -35,7 +40,8 @@
 
 public class OperationGroupByUntilTest {
     @Mock
-            Observer observer;
+    Observer observer;
+
      Func1 just(final R value) {
         return new Func1() {
             @Override
@@ -44,6 +50,7 @@ public R call(T t1) {
             }
         };
     }
+
      Func1 fail(T dummy) {
         return new Func1() {
             @Override
@@ -52,6 +59,7 @@ public T call(Integer t1) {
             }
         };
     }
+
      Func1 fail2(R dummy2) {
         return new Func1() {
             @Override
@@ -60,6 +68,7 @@ public R call(T t1) {
             }
         };
     }
+
     Func1 dbl = new Func1() {
         @Override
         public Integer call(Integer t1) {
@@ -67,10 +76,12 @@ public Integer call(Integer t1) {
         }
     };
     Func1 identity = Functions.identity();
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     @Test
     public void normalBehavior() {
         Observable source = Observable.from(Arrays.asList(
@@ -86,8 +97,8 @@ public void normalBehavior() {
                 "baz  ",
                 " bAZ ",
                 "    fOo    "
-        ));
-        
+                ));
+
         Func1, Observable> duration = new Func1, Observable>() {
             @Override
             public Observable call(GroupedObservable t1) {
@@ -95,12 +106,12 @@ public Observable call(GroupedObservable t1) {
             }
         };
         Func1, String> getkey = new Func1, String>() {
-            
+
             @Override
             public String call(GroupedObservable t1) {
                 return t1.getKey();
             }
-            
+
         };
         Func1 keysel = new Func1() {
             @Override
@@ -114,13 +125,13 @@ public String call(String t1) {
                 return t1 + t1;
             }
         };
-        
+
         Observable m = source.groupByUntil(
                 keysel, valuesel,
                 duration).map(getkey);
-        
+
         m.subscribe(observer);
-        
+
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onNext("foo");
         inOrder.verify(observer, times(1)).onNext("bar");
@@ -130,18 +141,19 @@ public String call(String t1) {
         inOrder.verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void behaveAsGroupBy() {
         Observable source = Observable.from(0, 1, 2, 3, 4, 5, 6);
-        
+
         Func1, Observable> duration = just(Observable.never());
-        
+
         Observable> m = source.groupByUntil(
                 identity, dbl,
                 duration);
-        
+
         final Map actual = new HashMap();
-        
+
         m.subscribe(new Action1>() {
             @Override
             public void call(final GroupedObservable t1) {
@@ -153,85 +165,89 @@ public void call(Integer t2) {
                 });
             }
         });
-        
+
         Map expected = new HashMap();
         for (int i = 0; i < 7; i++) {
             expected.put(i, i * 2);
         }
-        
+
         Assert.assertEquals(expected, actual);
     }
+
     @Test
     public void keySelectorThrows() {
         Observable source = Observable.from(0, 1, 2, 3, 4, 5, 6);
-        
+
         Func1, Observable> duration = just(Observable.never());
-        
+
         Observable> m = source.groupByUntil(
                 fail(0), dbl,
                 duration);
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        
+
     }
+
     @Test
     public void valueSelectorThrows() {
         Observable source = Observable.from(0, 1, 2, 3, 4, 5, 6);
-        
+
         Func1, Observable> duration = just(Observable.never());
-        
+
         Observable> m = source.groupByUntil(
                 identity, fail(0),
                 duration);
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        
+
     }
+
     @Test
     public void durationSelectorThrows() {
         Observable source = Observable.from(0, 1, 2, 3, 4, 5, 6);
-        
-        Func1, Observable> duration = fail2((Observable)null);
-        
+
+        Func1, Observable> duration = fail2((Observable) null);
+
         Observable> m = source.groupByUntil(
                 identity, dbl,
                 duration);
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        
+
     }
+
     @Test
     public void durationThrows() {
         Observable source = Observable.from(0, 1, 2, 3, 4, 5, 6);
-        
+
         Func1, Integer> getkey = new Func1, Integer>() {
-            
+
             @Override
             public Integer call(GroupedObservable t1) {
                 return t1.getKey();
             }
-            
+
         };
         Func1, Observable> duration = just(Observable.error(new RuntimeException("Forced failure")));
-        
+
         Observable m = source.groupByUntil(
                 identity, dbl,
                 duration).map(getkey);
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onNext(0);
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(1);
@@ -241,60 +257,61 @@ public Integer call(GroupedObservable t1) {
         verify(observer, never()).onNext(5);
         verify(observer, never()).onNext(6);
         verify(observer, never()).onCompleted();
-        
+
     }
+
     @Test
     public void innerEscapeCompleted() {
         Observable source = Observable.from(0);
-        
+
         final AtomicReference> inner = new AtomicReference>();
-        
+
         Func1, Observable> duration = just(Observable.never());
-        
+
         Observable> m = source.groupByUntil(identity, dbl, duration);
-        
+
         m.subscribe(new Action1>() {
             @Override
             public void call(GroupedObservable t1) {
                 inner.set(t1);
             }
         });
-        
+
         inner.get().subscribe(observer);
-        
+
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
     }
-    
+
     @Test
     public void innerEscapeError() {
-        Observable source = Observable.concat(Observable.from(0), Observable.error(new RuntimeException("Forced failure")));
-        
+        Observable source = Observable.concat(Observable.from(0), Observable. error(new RuntimeException("Forced failure")));
+
         final AtomicReference> inner = new AtomicReference>();
-        
+
         Func1, Observable> duration = just(Observable.never());
-        
+
         Observable> m = source.groupByUntil(identity, dbl, duration);
-        
+
         m.subscribe(new Observer>() {
             @Override
             public void onNext(GroupedObservable t1) {
                 inner.set(t1);
             }
-            
+
             @Override
             public void onError(Throwable e) {
             }
-            
+
             @Override
             public void onCompleted() {
             }
-            
+
         });
-        
+
         inner.get().subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
index eb51fb5377..dc572db995 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
@@ -1,12 +1,12 @@
 /**
  * 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.
@@ -15,15 +15,16 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.Arrays;
+
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Matchers.any;
 import org.mockito.Mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.subjects.PublishSubject;
@@ -33,14 +34,15 @@
 
 public class OperationGroupJoinTest {
     @Mock
-            Observer observer;
-    
+    Observer observer;
+
     Func2 add = new Func2() {
         @Override
         public Integer call(Integer t1, Integer t2) {
             return t1 + t2;
         }
     };
+
      Func1> just(final Observable observable) {
         return new Func1>() {
             @Override
@@ -49,6 +51,7 @@ public Observable call(Integer t1) {
             }
         };
     }
+
      Func1> just2(final Observable observable) {
         return new Func1>() {
             @Override
@@ -57,6 +60,7 @@ public Observable call(T t1) {
             }
         };
     }
+
     Func2, Observable> add2 = new Func2, Observable>() {
         @Override
         public Observable call(final Integer leftValue, Observable rightValues) {
@@ -67,34 +71,36 @@ public Integer call(Integer rightValue) {
                 }
             });
         }
-        
+
     };
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     @Test
     public void behaveAsJoin() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Observable m = Observable.merge(source1.groupJoin(source2,
                 just(Observable.never()),
                 just(Observable.never()), add2));
-        
+
         m.subscribe(observer);
-        
+
         source1.onNext(1);
         source1.onNext(2);
         source1.onNext(4);
-        
+
         source2.onNext(16);
         source2.onNext(32);
         source2.onNext(64);
-        
+
         source1.onCompleted();
         source2.onCompleted();
-        
+
         verify(observer, times(1)).onNext(17);
         verify(observer, times(1)).onNext(18);
         verify(observer, times(1)).onNext(20);
@@ -104,59 +110,66 @@ public void behaveAsJoin() {
         verify(observer, times(1)).onNext(65);
         verify(observer, times(1)).onNext(66);
         verify(observer, times(1)).onNext(68);
-        
+
         verify(observer, times(1)).onCompleted(); //Never emitted?
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     class Person {
         final int id;
         final String name;
+
         public Person(int id, String name) {
             this.id = id;
             this.name = name;
         }
     }
+
     class PersonFruit {
         final int personId;
         final String fruit;
+
         public PersonFruit(int personId, String fruit) {
             this.personId = personId;
             this.fruit = fruit;
         }
     }
+
     class PPF {
         final Person person;
         final Observable fruits;
+
         public PPF(Person person, Observable fruits) {
             this.person = person;
             this.fruits = fruits;
         }
     }
+
     @Test
     public void normal1() {
         Observable source1 = Observable.from(Arrays.asList(
                 new Person(1, "Joe"),
                 new Person(2, "Mike"),
                 new Person(3, "Charlie")
-        ));
-        
+                ));
+
         Observable source2 = Observable.from(Arrays.asList(
                 new PersonFruit(1, "Strawberry"),
                 new PersonFruit(1, "Apple"),
                 new PersonFruit(3, "Peach")
-        ));
-        
+                ));
+
         Observable q = source1.groupJoin(
                 source2,
-                just2(Observable.never()),
-                just2(Observable.never()),
+                just2(Observable. never()),
+                just2(Observable. never()),
                 new Func2, PPF>() {
                     @Override
                     public PPF call(Person t1, Observable t2) {
                         return new PPF(t1, t2);
                     }
                 });
-        
+
         q.subscribe(
                 new Observer() {
                     @Override
@@ -173,170 +186,172 @@ public void call(PersonFruit t1) {
                             }
                         });
                     }
-                    
+
                     @Override
                     public void onError(Throwable e) {
                         observer.onError(e);
                     }
-                    
+
                     @Override
                     public void onCompleted() {
                         observer.onCompleted();
                     }
-                    
+
                 }
-        );
-        
+                );
+
         verify(observer, times(1)).onNext(Arrays.asList("Joe", "Strawberry"));
         verify(observer, times(1)).onNext(Arrays.asList("Joe", "Apple"));
         verify(observer, times(1)).onNext(Arrays.asList("Charlie", "Peach"));
-        
+
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void leftThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Observable> m = source1.groupJoin(source2,
                 just(Observable.never()),
                 just(Observable.never()), add2);
-        
+
         m.subscribe(observer);
-        
+
         source2.onNext(1);
         source1.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Observable> m = source1.groupJoin(source2,
                 just(Observable.never()),
                 just(Observable.never()), add2);
-        
+
         m.subscribe(observer);
-        
+
         source1.onNext(1);
         source2.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, times(1)).onNext(any(Observable.class));
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void leftDurationThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable duration1 = Observable.error(new RuntimeException("Forced failure"));
-        
+
+        Observable duration1 = Observable. error(new RuntimeException("Forced failure"));
+
         Observable> m = source1.groupJoin(source2,
                 just(duration1),
                 just(Observable.never()), add2);
         m.subscribe(observer);
-        
+
         source1.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightDurationThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable duration1 = Observable.error(new RuntimeException("Forced failure"));
-        
+
+        Observable duration1 = Observable. error(new RuntimeException("Forced failure"));
+
         Observable> m = source1.groupJoin(source2,
                 just(Observable.never()),
                 just(duration1), add2);
         m.subscribe(observer);
-        
+
         source2.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void leftDurationSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Func1> fail = new Func1>() {
             @Override
             public Observable call(Integer t1) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Observable> m = source1.groupJoin(source2,
                 fail,
                 just(Observable.never()), add2);
         m.subscribe(observer);
-        
+
         source1.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightDurationSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Func1> fail = new Func1>() {
             @Override
             public Observable call(Integer t1) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Observable> m = source1.groupJoin(source2,
                 just(Observable.never()),
                 fail, add2);
         m.subscribe(observer);
-        
+
         source2.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void resultSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Func2, Integer> fail = new Func2, Integer>() {
             @Override
             public Integer call(Integer t1, Observable t2) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Observable m = source1.groupJoin(source2,
                 just(Observable.never()),
                 just(Observable.never()), fail);
         m.subscribe(observer);
-        
+
         source1.onNext(1);
         source2.onNext(2);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
index 23c786fc89..b496557288 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -27,8 +27,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.schedulers.TestScheduler;
 import rx.observables.ConnectableObservable;
+import rx.schedulers.TestScheduler;
 
 public class OperationIntervalTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
index 8f841ebb50..ff2591c83e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
@@ -15,32 +15,31 @@
  */
 package rx.operators;
 
-import java.util.Collection;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Matchers.any;
 import org.mockito.Mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 public class OperationJoinTest {
     @Mock
     Observer observer;
-    
+
     Func2 add = new Func2() {
         @Override
         public Integer call(Integer t1, Integer t2) {
             return t1 + t2;
         }
     };
+
      Func1> just(final Observable observable) {
         return new Func1>() {
             @Override
@@ -49,32 +48,34 @@ public Observable call(Integer t1) {
             }
         };
     }
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     @Test
     public void normal1() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(Observable.never()), add);
 
         m.subscribe(observer);
-        
+
         source1.onNext(1);
         source1.onNext(2);
         source1.onNext(4);
-        
+
         source2.onNext(16);
         source2.onNext(32);
         source2.onNext(64);
-        
+
         source1.onCompleted();
         source2.onCompleted();
-        
+
         verify(observer, times(1)).onNext(17);
         verify(observer, times(1)).onNext(18);
         verify(observer, times(1)).onNext(20);
@@ -84,148 +85,153 @@ public void normal1() {
         verify(observer, times(1)).onNext(65);
         verify(observer, times(1)).onNext(66);
         verify(observer, times(1)).onNext(68);
-        
+
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void normal1WithDuration() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
 
         PublishSubject duration1 = PublishSubject.create();
-        
-        Observable m = source1.join(source2, 
-                just(duration1), 
+
+        Observable m = source1.join(source2,
+                just(duration1),
                 just(Observable.never()), add);
         m.subscribe(observer);
 
         source1.onNext(1);
         source1.onNext(2);
         source2.onNext(16);
-        
+
         duration1.onNext(1);
-        
+
         source1.onNext(4);
         source1.onNext(8);
-        
+
         source1.onCompleted();
         source2.onCompleted();
-        
+
         verify(observer, times(1)).onNext(17);
         verify(observer, times(1)).onNext(18);
         verify(observer, times(1)).onNext(20);
         verify(observer, times(1)).onNext(24);
-        
+
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        
+
     }
+
     @Test
     public void normal2() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(Observable.never()), add);
 
         m.subscribe(observer);
-        
+
         source1.onNext(1);
         source1.onNext(2);
         source1.onCompleted();
-        
+
         source2.onNext(16);
         source2.onNext(32);
         source2.onNext(64);
-        
+
         source2.onCompleted();
-        
+
         verify(observer, times(1)).onNext(17);
         verify(observer, times(1)).onNext(18);
         verify(observer, times(1)).onNext(33);
         verify(observer, times(1)).onNext(34);
         verify(observer, times(1)).onNext(65);
         verify(observer, times(1)).onNext(66);
-        
+
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void leftThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(Observable.never()), add);
 
         m.subscribe(observer);
 
         source2.onNext(1);
         source1.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(Observable.never()), add);
 
         m.subscribe(observer);
 
         source1.onNext(1);
         source2.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void leftDurationThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
 
-        Observable duration1 = Observable.error(new RuntimeException("Forced failure"));
-        
-        Observable m = source1.join(source2, 
-                just(duration1), 
+        Observable duration1 = Observable. error(new RuntimeException("Forced failure"));
+
+        Observable m = source1.join(source2,
+                just(duration1),
                 just(Observable.never()), add);
         m.subscribe(observer);
 
         source1.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightDurationThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
 
-        Observable duration1 = Observable.error(new RuntimeException("Forced failure"));
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+        Observable duration1 = Observable. error(new RuntimeException("Forced failure"));
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(duration1), add);
         m.subscribe(observer);
 
         source2.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void leftDurationSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
@@ -237,19 +243,19 @@ public Observable call(Integer t1) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
-        Observable m = source1.join(source2, 
-                fail, 
+
+        Observable m = source1.join(source2,
+                fail,
                 just(Observable.never()), add);
         m.subscribe(observer);
 
         source1.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void rightDurationSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
@@ -261,40 +267,39 @@ public Observable call(Integer t1) {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 fail, add);
         m.subscribe(observer);
 
         source2.onNext(1);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
     }
+
     @Test
     public void resultSelectorThrows() {
         PublishSubject source1 = PublishSubject.create();
         PublishSubject source2 = PublishSubject.create();
-        
+
         Func2 fail = new Func2() {
             @Override
             public Integer call(Integer t1, Integer t2) {
                 throw new RuntimeException("Forced failure");
-            }            
+            }
         };
-        
-        Observable m = source1.join(source2, 
-                just(Observable.never()), 
+
+        Observable m = source1.join(source2,
+                just(Observable.never()),
                 just(Observable.never()), fail);
         m.subscribe(observer);
 
         source1.onNext(1);
         source2.onNext(2);
-        
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
         verify(observer, never()).onNext(any());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
index 53b6dffbf6..65606b5055 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
@@ -15,16 +15,15 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
-import static org.mockito.Matchers.any;
 import org.mockito.Mock;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.joins.Plan0;
@@ -37,8 +36,7 @@
 public class OperationJoinsTest {
     @Mock
     Observer observer;
-    
-    
+
     Func2 add2 = new Func2() {
         @Override
         public Integer call(Integer t1, Integer t2) {
@@ -57,7 +55,7 @@ public Integer call(Integer t1, Integer t2) {
             return t1 - t2;
         }
     };
-    
+
     Func3 add3 = new Func3() {
         @Override
         public Integer call(Integer t1, Integer t2, Integer t3) {
@@ -82,280 +80,302 @@ public Integer call(Integer t1, Integer t2, Integer t3) {
             throw new RuntimeException("Forced failure");
         }
     };
-    
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void and2ArgumentNull() {
         Observable some = Observable.just(1);
         some.and(null);
     }
+
     @Test(expected = NullPointerException.class)
     public void and3argumentNull() {
         Observable some = Observable.just(1);
         some.and(some).and(null);
     }
+
     @Test
     public void and2() {
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(some).then(add2));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(2);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void and2Error1() {
         Observable error = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(error.and(some).then(add2));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void and2Error2() {
         Observable error = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(error).then(add2));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void and3() {
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(some).and(some).then(add3));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(3);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void and3Error1() {
         Observable error = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(error.and(some).and(some).then(add3));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void and3Error2() {
         Observable error = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(error).and(some).then(add3));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void and3Error3() {
         Observable error = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(some).and(error).then(add3));
-        
+
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test(expected = NullPointerException.class)
     public void thenArgumentNull() {
         Observable some = Observable.just(1);
-        
+
         some.then(null);
     }
+
     @Test(expected = NullPointerException.class)
     public void then2ArgumentNull() {
         Observable some = Observable.just(1);
-        
+
         some.and(some).then(null);
     }
+
     @Test(expected = NullPointerException.class)
     public void then3ArgumentNull() {
         Observable some = Observable.just(1);
-        
+
         some.and(some).and(some).then(null);
     }
+
     @Test
     public void then1() {
         Observable some = Observable.just(1);
-        
-        Observable m = Observable.when(some.then(Functions.identity()));
+
+        Observable m = Observable.when(some.then(Functions. identity()));
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(1);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void then1Error() {
         Observable some = Observable.error(new RuntimeException("Forced failure"));
-        
-        Observable m = Observable.when(some.then(Functions.identity()));
+
+        Observable m = Observable.when(some.then(Functions. identity()));
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void then1Throws() {
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.then(func1Throw));
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void then2Throws() {
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(some).then(func2Throw));
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void then3Throws() {
         Observable some = Observable.just(1);
-        
+
         Observable m = Observable.when(some.and(some).and(some).then(func3Throw));
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test(expected = NullPointerException.class)
     public void whenArgumentNull1() {
-        Observable.when((Plan0[])null);
+        Observable.when((Plan0[]) null);
     }
+
     @Test(expected = NullPointerException.class)
     public void whenArgumentNull2() {
-        Observable.when((Iterable>)null);
+        Observable.when((Iterable>) null);
     }
+
     @Test
     public void whenMultipleSymmetric() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5, 6);
-        
+
         Observable m = Observable.when(source1.and(source2).then(add2));
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(1 + 4);
         verify(observer, times(1)).onNext(2 + 5);
         verify(observer, times(1)).onNext(3 + 6);
-        verify(observer, times(1)).onCompleted();        
+        verify(observer, times(1)).onCompleted();
     }
-    
+
     @Test
     public void whenMultipleAsymSymmetric() {
         Observable source1 = Observable.from(1, 2, 3);
         Observable source2 = Observable.from(4, 5);
-        
+
         Observable m = Observable.when(source1.and(source2).then(add2));
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(1 + 4);
         verify(observer, times(1)).onNext(2 + 5);
-        verify(observer, times(1)).onCompleted();        
+        verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void whenEmptyEmpty() {
         Observable source1 = Observable.empty();
         Observable source2 = Observable.empty();
-        
+
         Observable m = Observable.when(source1.and(source2).then(add2));
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
-        verify(observer, times(1)).onCompleted();        
+        verify(observer, times(1)).onCompleted();
     }
-    
+
     @Test
     public void whenNeverNever() {
         Observable source1 = Observable.never();
         Observable source2 = Observable.never();
-        
+
         Observable m = Observable.when(source1.and(source2).then(add2));
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
-        verify(observer, never()).onCompleted();        
+        verify(observer, never()).onCompleted();
     }
+
     @Test
     public void whenThrowNonEmpty() {
         Observable source1 = Observable.empty();
         Observable source2 = Observable.error(new RuntimeException("Forced failure"));
-        
+
         Observable m = Observable.when(source1.and(source2).then(add2));
         m.subscribe(observer);
-        
+
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
-        verify(observer, never()).onCompleted();        
+        verify(observer, never()).onCompleted();
     }
+
     @Test
     public void whenComplicated() {
         PublishSubject xs = PublishSubject.create();
         PublishSubject ys = PublishSubject.create();
         PublishSubject zs = PublishSubject.create();
-        
+
         Observable m = Observable.when(
-            xs.and(ys).then(add2),
-            xs.and(zs).then(mul2),
-            ys.and(zs).then(sub2)
-        );
+                xs.and(ys).then(add2),
+                xs.and(zs).then(mul2),
+                ys.and(zs).then(sub2)
+                );
         m.subscribe(observer);
-        
+
         xs.onNext(1); // t == 210
-        
+
         xs.onNext(2); // t == 220
         zs.onNext(7); // t == 220
-        
+
         xs.onNext(3); // t == 230
         zs.onNext(8); // t == 230
 
@@ -364,19 +384,19 @@ public void whenComplicated() {
         xs.onCompleted(); // t == 240
 
         ys.onNext(5); // t == 250
-        
+
         ys.onNext(6); // t == 260
-        
+
         ys.onCompleted(); // t == 270
-        
+
         zs.onCompleted(); // t == 300
-        
+
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onNext(1 * 7);
         inOrder.verify(observer, times(1)).onNext(2 * 8);
         inOrder.verify(observer, times(1)).onNext(3 + 4);
         inOrder.verify(observer, times(1)).onNext(5 - 9);
-        inOrder.verify(observer, times(1)).onCompleted();         
+        inOrder.verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
index cfd292cff2..ec3f1e5432 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
@@ -16,10 +16,8 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -41,7 +39,7 @@ public void testLastWithNoElements() {
         Observable last = Observable.empty().last();
         last.toBlockingObservable().single();
     }
-    
+
     @Test
     public void testLastMultiSubscribe() {
         Observable last = Observable.from(1, 2, 3).last();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java
index 3dde8610f9..b448b8f2ea 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java
@@ -1,25 +1,28 @@
- /**
-  * 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.
-  */
+/**
+ * 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 java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.concurrent.TimeUnit;
+
 import junit.framework.Assert;
+
 import org.junit.Test;
+
 import rx.Observable;
 import rx.observables.BlockingObservable;
 import rx.schedulers.TestScheduler;
@@ -29,134 +32,140 @@ public class OperationLatestTest {
     @Test(timeout = 1000)
     public void testSimple() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
-        
+
         Iterable iter = source.latest();
-        
+
         Iterator it = iter.iterator();
-        
+
         // only 9 because take(10) will immediately call onCompleted when receiving the 10th item
         // which onCompleted will overwrite the previous value
         for (int i = 0; i < 9; i++) {
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             Assert.assertEquals(true, it.hasNext());
-            
+
             Assert.assertEquals(Long.valueOf(i), it.next());
         }
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
         Assert.assertEquals(false, it.hasNext());
     }
+
     @Test(timeout = 1000)
     public void testSameSourceMultipleIterators() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
-        
+
         Iterable iter = source.latest();
-        
+
         for (int j = 0; j < 3; j++) {
             Iterator it = iter.iterator();
-            
+
             // only 9 because take(10) will immediately call onCompleted when receiving the 10th item
             // which onCompleted will overwrite the previous value
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-                
+
                 Assert.assertEquals(true, it.hasNext());
-                
+
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
             Assert.assertEquals(false, it.hasNext());
         }
     }
+
     @Test(timeout = 1000, expected = NoSuchElementException.class)
     public void testEmpty() {
-        BlockingObservable source = Observable.empty().toBlockingObservable();
-        
+        BlockingObservable source = Observable. empty().toBlockingObservable();
+
         Iterable iter = source.latest();
-        
+
         Iterator it = iter.iterator();
-        
+
         Assert.assertEquals(false, it.hasNext());
-        
+
         it.next();
     }
+
     @Test(timeout = 1000, expected = NoSuchElementException.class)
     public void testSimpleJustNext() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
-        
+
         Iterable iter = source.latest();
-        
+
         Iterator it = iter.iterator();
-        
+
         // only 9 because take(10) will immediately call onCompleted when receiving the 10th item
         // which onCompleted will overwrite the previous value
         for (int i = 0; i < 10; i++) {
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             Assert.assertEquals(Long.valueOf(i), it.next());
         }
     }
-    @Test(/*timeout = 1000, */expected = RuntimeException.class)
+
+    @Test(/* timeout = 1000, */expected = RuntimeException.class)
     public void testHasNextThrows() {
         TestScheduler scheduler = new TestScheduler();
-        
-        BlockingObservable source = Observable.error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
-        
+
+        BlockingObservable source = Observable. error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
+
         Iterable iter = source.latest();
-        
+
         Iterator it = iter.iterator();
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         it.hasNext();
     }
+
     @Test(timeout = 1000, expected = RuntimeException.class)
     public void testNextThrows() {
         TestScheduler scheduler = new TestScheduler();
-        
-        BlockingObservable source = Observable.error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
-        
+
+        BlockingObservable source = Observable. error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
+
         Iterable iter = source.latest();
         Iterator it = iter.iterator();
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         it.next();
     }
+
     @Test(timeout = 1000)
     public void testFasterSource() {
         PublishSubject source = PublishSubject.create();
         BlockingObservable blocker = source.toBlockingObservable();
-        
+
         Iterable iter = blocker.latest();
         Iterator it = iter.iterator();
-        
+
         source.onNext(1);
-        
+
         Assert.assertEquals(Integer.valueOf(1), it.next());
-        
+
         source.onNext(2);
         source.onNext(3);
-        
+
         Assert.assertEquals(Integer.valueOf(3), it.next());
-        
+
         source.onNext(4);
         source.onNext(5);
         source.onNext(6);
-        
+
         Assert.assertEquals(Integer.valueOf(6), it.next());
-        
+
         source.onNext(7);
         source.onCompleted();
-        
+
         Assert.assertEquals(false, it.hasNext());
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
index 6f77433623..d8d0ad1f64 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMapTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -22,7 +22,6 @@
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Before;
@@ -280,22 +279,22 @@ public String call(String arg0) {
         // block for response, expecting exception thrown
         m.toBlockingObservable().last();
     }
-    
+
     /**
      * While mapping over range(1,1).last() we expect IllegalArgumentException since the sequence is empty.
      */
     @Test(expected = IllegalArgumentException.class)
     public void testErrorPassesThruMap() {
-        Observable.range(1,0).last().map(new Func1() {
+        Observable.range(1, 0).last().map(new Func1() {
 
             @Override
             public Integer call(Integer i) {
                 return i;
             }
-            
+
         }).toBlockingObservable().single();
     }
-    
+
     /**
      * We expect IllegalStateException to pass thru map.
      */
@@ -307,23 +306,23 @@ public void testErrorPassesThruMap2() {
             public Object call(Object i) {
                 return i;
             }
-            
+
         }).toBlockingObservable().single();
     }
-    
+
     /**
      * We expect an ArithmeticException exception here because last() emits a single value
      * but then we divide by 0.
      */
     @Test(expected = ArithmeticException.class)
     public void testMapWithErrorInFunc() {
-        Observable.range(1,1).last().map(new Func1() {
+        Observable.range(1, 1).last().map(new Func1() {
 
             @Override
             public Integer call(Integer i) {
-                return i/0;
+                return i / 0;
             }
-            
+
         }).toBlockingObservable().single();
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java b/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java
index 54d1ab0474..0caba284a5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
index 693b9d4801..010de4d00e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
index becf17d803..30753b3dc0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -480,7 +480,7 @@ public void testWhenMaxConcurrentIsOne() {
             List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five");
             Iterator iter = Observable.merge(os, 1).toBlockingObservable().toIterable().iterator();
             List actual = new ArrayList();
-            while(iter.hasNext()) {
+            while (iter.hasNext()) {
                 actual.add(iter.next());
             }
             assertEquals(expected, actual);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
index f2deff9e57..da09fcdf1a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
@@ -1,12 +1,12 @@
 /**
  * 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.
@@ -15,14 +15,9 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static rx.operators.OperationMinMax.max;
-import static rx.operators.OperationMinMax.maxBy;
-import static rx.operators.OperationMinMax.min;
-import static rx.operators.OperationMinMax.minBy;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.operators.OperationMinMax.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java
index 35382273fc..d708dbdd08 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -20,13 +20,13 @@
 
 import java.util.Iterator;
 import java.util.concurrent.TimeUnit;
-import org.junit.Assert;
 
+import org.junit.Assert;
 import org.junit.Test;
+
 import rx.Observable;
 import rx.observables.BlockingObservable;
 import rx.schedulers.TestScheduler;
-
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 
@@ -76,29 +76,29 @@ public void testMostRecentWithException() {
     private static class TestException extends RuntimeException {
         private static final long serialVersionUID = 1L;
     }
-    
+
     @Test(timeout = 1000)
     public void testSingleSourceManyIterators() {
         TestScheduler scheduler = new TestScheduler();
         BlockingObservable source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
-        
+
         Iterable iter = source.mostRecent(-1L);
-        
+
         for (int j = 0; j < 3; j++) {
             Iterator it = iter.iterator();
-            
+
             Assert.assertEquals(Long.valueOf(-1), it.next());
-            
+
             for (int i = 0; i < 9; i++) {
                 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-                
+
                 Assert.assertEquals(true, it.hasNext());
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             Assert.assertEquals(false, it.hasNext());
         }
-        
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java b/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
index 8f824f1484..87d1ae950d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java
index acbf5ed52e..cf6c3b3f0c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationNextTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -24,8 +24,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.Assert;
 
+import org.junit.Assert;
 import org.junit.Test;
 
 import rx.Observable;
@@ -33,7 +33,6 @@
 import rx.Subscription;
 import rx.observables.BlockingObservable;
 import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
@@ -296,25 +295,26 @@ public void run() {
 
         System.out.println("a: " + a + " b: " + b + " c: " + c);
     }
+
     @Test(timeout = 8000)
     public void testSingleSourceManyIterators() throws InterruptedException {
         BlockingObservable source = Observable.interval(200, TimeUnit.MILLISECONDS).take(10).toBlockingObservable();
-        
+
         Iterable iter = source.next();
-        
+
         for (int j = 0; j < 3; j++) {
             Iterator it = iter.iterator();
-            
+
             for (int i = 0; i < 9; i++) {
                 // hasNext has to set the waiting to true, otherwise, all onNext will be skipped
                 Assert.assertEquals(true, it.hasNext());
                 Assert.assertEquals(Long.valueOf(i), it.next());
             }
-            
+
             Thread.sleep(400);
-            
+
             Assert.assertEquals(false, it.hasNext());
         }
-        
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
index dfc14750c8..87a634b9f6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
@@ -213,7 +213,7 @@ public void observeSameOnMultipleSchedulers() {
         verify(observer2, never()).onError(any(Throwable.class));
         inOrder2.verifyNoMoreInteractions();
     }
-    
+
     /**
      * Confirm that running on a NewThreadScheduler uses the same thread for the entire stream
      */
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
index ab9293251e..272bfe2054 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
index dcbbdc3fb4..688c189a8a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
index e436dd29ee..fb416a001b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
index 8b5cc9271a..b584f13585 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationParallelTest.java b/rxjava-core/src/test/java/rx/operators/OperationParallelTest.java
index d52c8bc0b9..a9b4e547f0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationParallelTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationParallelTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
index c067f40179..8421775d90 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
@@ -33,44 +33,47 @@
 public class OperationReduceTest {
     @Mock
     Observer observer;
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     Func2 sum = new Func2() {
         @Override
         public Integer call(Integer t1, Integer t2) {
             return t1 + t2;
         }
     };
-    
+
     @Test
     public void testAggregateAsIntSum() {
-        
-        Observable result = Observable.from(1, 2, 3, 4, 5).reduce(0, sum).map(Functions.identity());
-        
+
+        Observable result = Observable.from(1, 2, 3, 4, 5).reduce(0, sum).map(Functions. identity());
+
         result.subscribe(observer);
-        
+
         verify(observer).onNext(1 + 2 + 3 + 4 + 5);
         verify(observer).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
-    static class CustomException extends RuntimeException { }
-    
+
+    static class CustomException extends RuntimeException {
+    }
+
     @Test
     public void testAggregateAsIntSumSourceThrows() {
         Observable result = Observable.concat(Observable.from(1, 2, 3, 4, 5),
-            Observable.error(new CustomException()))
-            .reduce(0, sum).map(Functions.identity());
-        
+                Observable. error(new CustomException()))
+                .reduce(0, sum).map(Functions. identity());
+
         result.subscribe(observer);
-        
+
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
         verify(observer, times(1)).onError(any(CustomException.class));
     }
-    
+
     @Test
     public void testAggregateAsIntSumAccumulatorThrows() {
         Func2 sumErr = new Func2() {
@@ -79,12 +82,12 @@ public Integer call(Integer t1, Integer t2) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = Observable.from(1, 2, 3, 4, 5)
-            .reduce(0, sumErr).map(Functions.identity());
-        
+                .reduce(0, sumErr).map(Functions. identity());
+
         result.subscribe(observer);
-        
+
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
         verify(observer, times(1)).onError(any(CustomException.class));
@@ -92,7 +95,7 @@ public Integer call(Integer t1, Integer t2) {
 
     @Test
     public void testAggregateAsIntSumResultSelectorThrows() {
-        
+
         Func1 error = new Func1() {
 
             @Override
@@ -100,12 +103,12 @@ public Integer call(Integer t1) {
                 throw new CustomException();
             }
         };
-        
+
         Observable result = Observable.from(1, 2, 3, 4, 5)
-            .reduce(0, sum).map(error);
-        
+                .reduce(0, sum).map(error);
+
         result.subscribe(observer);
-        
+
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
         verify(observer, times(1)).onError(any(CustomException.class));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
index 56f540d466..46a88ff16e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
@@ -15,12 +15,16 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
+
 import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.InOrder;
-import static org.mockito.Mockito.*;
+
 import rx.Observable;
 import rx.Observer;
 import rx.observables.ConnectableObservable;
@@ -33,59 +37,62 @@ public class OperationReplayTest {
     @Test
     public void testBoundedList() {
         VirtualBoundedList list = new VirtualBoundedList(3);
-        
+
         list.add(1); // idx: 0
         list.add(2); // idx: 1
         list.add(3); // idx: 2
-        
+
         Assert.assertEquals(3, list.size());
 
         list.add(4); // idx: 3
 
         Assert.assertEquals(3, list.size());
         Assert.assertEquals(Arrays.asList(2, 3, 4), list.toList());
-        
+
         Assert.assertEquals(1, list.start());
         Assert.assertEquals(4, list.end());
-        
+
         list.removeBefore(3);
-        
+
         Assert.assertEquals(1, list.size());
-        
+
         Assert.assertEquals(Arrays.asList(4), list.toList());
 
         Assert.assertEquals(3, list.start());
         Assert.assertEquals(4, list.end());
     }
+
     @Test(expected = ArrayIndexOutOfBoundsException.class)
     public void testReadBefore() {
         VirtualBoundedList list = new VirtualBoundedList(3);
-        
+
         list.add(1); // idx: 0
         list.add(2); // idx: 1
         list.add(3); // idx: 2
         list.add(4); // idx: 3
-        
+
         list.get(0);
     }
+
     @Test(expected = ArrayIndexOutOfBoundsException.class)
     public void testReadAfter() {
         VirtualBoundedList list = new VirtualBoundedList(3);
-        
+
         list.add(1); // idx: 0
         list.add(2); // idx: 1
         list.add(3); // idx: 2
         list.add(4); // idx: 3
-        
+
         list.get(4);
     }
+
     @Test
     public void testBufferedReplay() {
         PublishSubject source = PublishSubject.create();
-        
+
         ConnectableObservable co = source.replay(3);
         co.connect();
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -106,9 +113,9 @@ public void testBufferedReplay() {
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
-            
+
         }
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -123,15 +130,16 @@ public void testBufferedReplay() {
             verify(observer1, never()).onError(any(Throwable.class));
         }
     }
+
     @Test
     public void testWindowedReplay() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         ConnectableObservable co = source.replay(100, TimeUnit.MILLISECONDS, scheduler);
         co.connect();
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -150,24 +158,25 @@ public void testWindowedReplay() {
             inOrder.verify(observer1, times(1)).onNext(1);
             inOrder.verify(observer1, times(1)).onNext(2);
             inOrder.verify(observer1, times(1)).onNext(3);
-            
+
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
-            
-        }        
+
+        }
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
             co.subscribe(observer1);
             inOrder.verify(observer1, times(1)).onNext(3);
-            
+
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
         }
     }
+
     @Test
     public void testReplaySelector() {
         final Func1 dbl = new Func1() {
@@ -176,20 +185,20 @@ public void testReplaySelector() {
             public Integer call(Integer t1) {
                 return t1 * 2;
             }
-            
+
         };
-        
+
         Func1, Observable> selector = new Func1, Observable>() {
 
             @Override
             public Observable call(Observable t1) {
                 return t1.map(dbl);
             }
-            
+
         };
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable co = source.replay(selector);
 
         {
@@ -214,7 +223,7 @@ public Observable call(Observable t1) {
             verify(observer1, never()).onError(any(Throwable.class));
 
         }
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -228,32 +237,32 @@ public Observable call(Observable t1) {
         }
 
     }
-    
+
     @Test
     public void testBufferedReplaySelector() {
-        
+
         final Func1 dbl = new Func1() {
 
             @Override
             public Integer call(Integer t1) {
                 return t1 * 2;
             }
-            
+
         };
-        
+
         Func1, Observable> selector = new Func1, Observable>() {
 
             @Override
             public Observable call(Observable t1) {
                 return t1.map(dbl);
             }
-            
+
         };
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable co = source.replay(selector, 3);
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -274,9 +283,9 @@ public Observable call(Observable t1) {
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
-            
+
         }
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -288,33 +297,34 @@ public Observable call(Observable t1) {
             verify(observer1, never()).onError(any(Throwable.class));
         }
     }
+
     @Test
     public void testWindowedReplaySelector() {
-        
+
         final Func1 dbl = new Func1() {
 
             @Override
             public Integer call(Integer t1) {
                 return t1 * 2;
             }
-            
+
         };
-        
+
         Func1, Observable> selector = new Func1, Observable>() {
 
             @Override
             public Observable call(Observable t1) {
                 return t1.map(dbl);
             }
-            
+
         };
-        
+
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable co = source.replay(selector, 100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -333,30 +343,31 @@ public Observable call(Observable t1) {
             inOrder.verify(observer1, times(1)).onNext(2);
             inOrder.verify(observer1, times(1)).onNext(4);
             inOrder.verify(observer1, times(1)).onNext(6);
-            
+
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
-            
-        }        
+
+        }
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
             co.subscribe(observer1);
-            
+
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onError(any(Throwable.class));
         }
     }
+
     @Test
     public void testBufferedReplayError() {
         PublishSubject source = PublishSubject.create();
-        
+
         ConnectableObservable co = source.replay(3);
         co.connect();
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -373,14 +384,14 @@ public void testBufferedReplayError() {
 
             source.onNext(4);
             source.onError(new RuntimeException("Forced failure"));
-            
+
             inOrder.verify(observer1, times(1)).onNext(4);
             inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onCompleted();
-            
+
         }
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -395,15 +406,16 @@ public void testBufferedReplayError() {
             verify(observer1, never()).onCompleted();
         }
     }
+
     @Test
     public void testWindowedReplayError() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         ConnectableObservable co = source.replay(100, TimeUnit.MILLISECONDS, scheduler);
         co.connect();
-        
+
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
@@ -422,19 +434,19 @@ public void testWindowedReplayError() {
             inOrder.verify(observer1, times(1)).onNext(1);
             inOrder.verify(observer1, times(1)).onNext(2);
             inOrder.verify(observer1, times(1)).onNext(3);
-            
+
             inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onCompleted();
-            
-        }        
+
+        }
         {
             Observer observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
             co.subscribe(observer1);
             inOrder.verify(observer1, times(1)).onNext(3);
-            
+
             inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
             inOrder.verifyNoMoreInteractions();
             verify(observer1, never()).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java
index 1b6006b923..32c7847c36 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index 58c98895ec..4317817caa 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
@@ -107,14 +108,15 @@ public void call() {
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerNormal() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         source.onNext(2);
         sampler.onNext(1);
@@ -123,9 +125,8 @@ public void sampleWithSamplerNormal() {
         sampler.onNext(2);
         source.onCompleted();
         sampler.onNext(3);
-        
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, never()).onNext(1);
         inOrder.verify(observer2, times(1)).onNext(2);
         inOrder.verify(observer2, never()).onNext(3);
@@ -133,19 +134,20 @@ public void sampleWithSamplerNormal() {
         inOrder.verify(observer2, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerNoDuplicates() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         source.onNext(2);
         sampler.onNext(1);
         sampler.onNext(1);
-        
+
         source.onNext(3);
         source.onNext(4);
         sampler.onNext(2);
@@ -153,9 +155,8 @@ public void sampleWithSamplerNoDuplicates() {
 
         source.onCompleted();
         sampler.onNext(3);
-        
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, never()).onNext(1);
         inOrder.verify(observer2, times(1)).onNext(2);
         inOrder.verify(observer2, never()).onNext(3);
@@ -163,39 +164,39 @@ public void sampleWithSamplerNoDuplicates() {
         inOrder.verify(observer2, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerTerminatingEarly() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         source.onNext(2);
         sampler.onNext(1);
         sampler.onCompleted();
-        
+
         source.onNext(3);
         source.onNext(4);
 
-        
-        
-        InOrder inOrder = inOrder(observer2);  
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, never()).onNext(1);
         inOrder.verify(observer2, times(1)).onNext(2);
         inOrder.verify(observer2, times(1)).onCompleted();
         inOrder.verify(observer2, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerEmitAndTerminate() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         source.onNext(2);
         sampler.onNext(1);
@@ -203,8 +204,8 @@ public void sampleWithSamplerEmitAndTerminate() {
         source.onCompleted();
         sampler.onNext(2);
         sampler.onCompleted();
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, never()).onNext(1);
         inOrder.verify(observer2, times(1)).onNext(2);
         inOrder.verify(observer2, never()).onNext(3);
@@ -212,52 +213,55 @@ public void sampleWithSamplerEmitAndTerminate() {
         inOrder.verify(observer2, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerEmptySource() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onCompleted();
         sampler.onNext(1);
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, times(1)).onCompleted();
         verify(observer2, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void sampleWithSamplerSourceThrows() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         source.onError(new RuntimeException("Forced failure!"));
         sampler.onNext(1);
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, times(1)).onError(any(Throwable.class));
         verify(observer2, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void sampleWithSamplerThrows() {
         PublishSubject source = PublishSubject.create();
         PublishSubject sampler = PublishSubject.create();
-        
+
         Observable m = source.sample(sampler);
         m.subscribe(observer2);
-        
+
         source.onNext(1);
         sampler.onNext(1);
         sampler.onError(new RuntimeException("Forced failure!"));
-        
-        InOrder inOrder = inOrder(observer2);  
+
+        InOrder inOrder = inOrder(observer2);
         inOrder.verify(observer2, times(1)).onNext(1);
         inOrder.verify(observer2, times(1)).onError(any(RuntimeException.class));
         verify(observer, never()).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java b/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
index 0dedef787c..d79264a298 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
index 71aa64130c..53360b5356 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
@@ -15,10 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
index b89864b1e4..1bba49a7f7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
@@ -15,10 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
index 27e1b1e126..6664fda2af 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,10 +15,12 @@
  */
 package rx.operators;
 
-import java.util.concurrent.TimeUnit;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationSkipLast.*;
 
+import java.util.concurrent.TimeUnit;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -114,32 +116,32 @@ public void testSkipLastWithNegativeCount() {
                 any(IndexOutOfBoundsException.class));
         verify(aObserver, never()).onCompleted();
     }
-    
+
     @Test
     public void testSkipLastTimed() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         source.onNext(4);
         source.onNext(5);
         source.onNext(6);
 
         scheduler.advanceTimeBy(950, TimeUnit.MILLISECONDS);
         source.onCompleted();
-                
+
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
@@ -149,60 +151,59 @@ public void testSkipLastTimed() {
         inOrder.verify(o, never()).onNext(6);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testSkipLastTimedErrorBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onError(new OperationSkipTest.CustomException());
-        
+
         scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
 
         verify(o).onError(any(CustomException.class));
-     
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
     }
-    
+
     @Test
     public void testSkipLastTimedCompleteBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
 
         scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         source.onCompleted();
-        
-        
+
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
index 44f08d2402..6dfa90c196 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,10 +15,12 @@
  */
 package rx.operators;
 
-import java.util.concurrent.TimeUnit;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationSkip.*;
 
+import java.util.concurrent.TimeUnit;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -58,33 +60,33 @@ public void testSkip2() {
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, times(1)).onCompleted();
     }
-    
+
     @Test
     public void testSkipTimed() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(4);
         source.onNext(5);
         source.onNext(6);
-        
+
         source.onCompleted();
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         inOrder.verify(o, never()).onNext(1);
         inOrder.verify(o, never()).onNext(2);
         inOrder.verify(o, never()).onNext(3);
@@ -95,85 +97,90 @@ public void testSkipTimed() {
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testSkipTimedFinishBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onCompleted();
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
-    static class CustomException extends RuntimeException { }
+
+    static class CustomException extends RuntimeException {
+    }
+
     @Test
     public void testSkipTimedErrorBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onError(new CustomException());
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         inOrder.verify(o).onError(any(CustomException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
+
     @Test
     public void testSkipTimedErrorAfterTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.skip(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(4);
         source.onNext(5);
         source.onNext(6);
-        
+
         source.onError(new CustomException());
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         inOrder.verify(o, never()).onNext(1);
         inOrder.verify(o, never()).onNext(2);
         inOrder.verify(o, never()).onNext(3);
@@ -183,6 +190,6 @@ public void testSkipTimedErrorAfterTime() {
         inOrder.verify(o).onError(any(CustomException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onCompleted();
-        
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
index 2acca312df..0f4f28ca42 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
@@ -15,14 +15,14 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Matchers.any;
 import org.mockito.Mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.subjects.PublishSubject;
@@ -30,126 +30,131 @@
 public class OperationSkipUntilTest {
     @Mock
     Observer observer;
-    
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
-    
+
     @Test
     public void normal1() {
         PublishSubject source = PublishSubject.create();
         PublishSubject other = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(other);
         m.subscribe(observer);
-        
+
         source.onNext(0);
         source.onNext(1);
-        
+
         other.onNext(100);
-        
+
         source.onNext(2);
         source.onNext(3);
         source.onNext(4);
         source.onCompleted();
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(2);
         verify(observer, times(1)).onNext(3);
         verify(observer, times(1)).onNext(4);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void otherNeverFires() {
         PublishSubject source = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(Observable.never());
 
         m.subscribe(observer);
-        
+
         source.onNext(0);
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onNext(4);
         source.onCompleted();
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void otherEmpty() {
         PublishSubject source = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(Observable.empty());
 
         m.subscribe(observer);
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void otherFiresAndCompletes() {
         PublishSubject source = PublishSubject.create();
         PublishSubject other = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(other);
         m.subscribe(observer);
-        
+
         source.onNext(0);
         source.onNext(1);
-        
+
         other.onNext(100);
         other.onCompleted();
-        
+
         source.onNext(2);
         source.onNext(3);
         source.onNext(4);
         source.onCompleted();
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onNext(2);
         verify(observer, times(1)).onNext(3);
         verify(observer, times(1)).onNext(4);
         verify(observer, times(1)).onCompleted();
     }
+
     @Test
     public void sourceThrows() {
         PublishSubject source = PublishSubject.create();
         PublishSubject other = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(other);
         m.subscribe(observer);
-        
+
         source.onNext(0);
         source.onNext(1);
-        
+
         other.onNext(100);
         other.onCompleted();
-        
+
         source.onNext(2);
         source.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, times(1)).onNext(2);
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void otherThrowsImmediately() {
         PublishSubject source = PublishSubject.create();
         PublishSubject other = PublishSubject.create();
-        
+
         Observable m = source.skipUntil(other);
         m.subscribe(observer);
-        
+
         source.onNext(0);
         source.onNext(1);
-        
+
         other.onError(new RuntimeException("Forced failure"));
-        
+
         verify(observer, never()).onNext(any());
         verify(observer, times(1)).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
index 153c9fb14e..94c5a0aa0c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
index 3f605abf97..2cf15042dd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index 78aee09ede..00b6e8e33d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -123,18 +123,19 @@ public void testEmptySumDoubles() throws Throwable {
         verify(wd, never()).onError(any(Throwable.class));
         verify(wd, times(1)).onCompleted();
     }
-    
+
     void testThrows(Observer o, Class errorClass) {
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o, times(1)).onError(any(errorClass));
     }
+
      void testValue(Observer o, N value) {
         verify(o, times(1)).onNext(value);
         verify(o, times(1)).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testIntegerSumSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
@@ -144,61 +145,65 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        
+
         Observable result = source.sumInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 10);
     }
+
     @Test
     public void testLongSumSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Long call(String t1) {
-                return (long)t1.length();
+                return (long) t1.length();
             }
         };
-        
+
         Observable result = source.sumLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 10L);
     }
+
     @Test
     public void testFloatSumSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Float call(String t1) {
-                return (float)t1.length();
+                return (float) t1.length();
             }
         };
-        
+
         Observable result = source.sumFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 10f);
     }
+
     @Test
     public void testDoubleSumSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
         Func1 length = new Func1() {
             @Override
             public Double call(String t1) {
-                return (double)t1.length();
+                return (double) t1.length();
             }
         };
-        
+
         Observable result = source.sumDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testValue(o, 10d);
     }
+
     @Test
     public void testIntegerSumSelectorEmpty() {
         Observable source = Observable.empty();
@@ -208,61 +213,65 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        
+
         Observable result = source.sumInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testLongSumSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Long call(String t1) {
-                return (long)t1.length();
+                return (long) t1.length();
             }
         };
-        
+
         Observable result = source.sumLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testFloatSumSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Float call(String t1) {
-                return (float)t1.length();
+                return (float) t1.length();
             }
         };
-        
+
         Observable result = source.sumFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testDoubleSumSelectorEmpty() {
         Observable source = Observable.empty();
         Func1 length = new Func1() {
             @Override
             public Double call(String t1) {
-                return (double)t1.length();
+                return (double) t1.length();
             }
         };
-        
+
         Observable result = source.sumDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, IllegalArgumentException.class);
     }
+
     @Test
     public void testIntegerSumSelectorThrows() {
         Observable source = Observable.from("a");
@@ -272,13 +281,14 @@ public Integer call(String t1) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         Observable result = source.sumInteger(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, OperationReduceTest.CustomException.class);
     }
+
     @Test
     public void testLongSumSelectorThrows() {
         Observable source = Observable.from("a");
@@ -288,13 +298,14 @@ public Long call(String t1) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         Observable result = source.sumLong(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, OperationReduceTest.CustomException.class);
     }
+
     @Test
     public void testFloatSumSelectorThrows() {
         Observable source = Observable.from("a");
@@ -304,13 +315,14 @@ public Float call(String t1) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         Observable result = source.sumFloat(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, OperationReduceTest.CustomException.class);
     }
+
     @Test
     public void testDoubleSumSelectorThrows() {
         Observable source = Observable.from("a");
@@ -320,11 +332,11 @@ public Double call(String t1) {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         Observable result = source.sumDouble(length);
         Observer o = mock(Observer.class);
         result.subscribe(o);
-        
+
         testThrows(o, OperationReduceTest.CustomException.class);
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index 76490f1cec..c6cbfbc519 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java b/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java
index 73db076000..e7bdbcc3de 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
index 763e3f4c1e..acf7188e4c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,10 +15,12 @@
  */
 package rx.operators;
 
-import java.util.concurrent.TimeUnit;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationTakeLast.*;
 
+import java.util.concurrent.TimeUnit;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -112,21 +114,21 @@ public void testTakeLastWithNegativeCount() {
                 any(IndexOutOfBoundsException.class));
         verify(aObserver, never()).onCompleted();
     }
-    
+
     @Test
     public void takeLastTimed() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         InOrder inOrder = inOrder(o);
 
         result.subscribe(o);
-        
+
         source.onNext(1); // T: 0ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(2); // T: 250ms
@@ -138,29 +140,30 @@ public void takeLastTimed() {
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onCompleted(); // T: 1250ms
-        
+
         inOrder.verify(o, times(1)).onNext(2);
         inOrder.verify(o, times(1)).onNext(3);
         inOrder.verify(o, times(1)).onNext(4);
         inOrder.verify(o, times(1)).onNext(5);
         inOrder.verify(o, times(1)).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void takeLastTimedDelayCompletion() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1); // T: 0ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(2); // T: 250ms
@@ -172,26 +175,27 @@ public void takeLastTimedDelayCompletion() {
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(1250, TimeUnit.MILLISECONDS);
         source.onCompleted(); // T: 2250ms
-        
+
         inOrder.verify(o, times(1)).onCompleted();
 
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void takeLastTimedWithCapacity() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.takeLast(2, 1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         InOrder inOrder = inOrder(o);
 
         result.subscribe(o);
-        
+
         source.onNext(1); // T: 0ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(2); // T: 250ms
@@ -203,30 +207,32 @@ public void takeLastTimedWithCapacity() {
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onCompleted(); // T: 1250ms
-        
+
         inOrder.verify(o, times(1)).onNext(4);
         inOrder.verify(o, times(1)).onNext(5);
         inOrder.verify(o, times(1)).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
+
     static final class CustomException extends RuntimeException {
-        
+
     }
+
     @Test
     public void takeLastTimedThrowingSource() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         InOrder inOrder = inOrder(o);
 
         result.subscribe(o);
-        
+
         source.onNext(1); // T: 0ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(2); // T: 250ms
@@ -238,27 +244,27 @@ public void takeLastTimedThrowingSource() {
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onError(new CustomException()); // T: 1250ms
-        
+
         inOrder.verify(o, times(1)).onError(any(CustomException.class));
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
-    
+
     @Test
     public void takeLastTimedWithZeroCapacity() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.takeLast(0, 1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         InOrder inOrder = inOrder(o);
 
         result.subscribe(o);
-        
+
         source.onNext(1); // T: 0ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(2); // T: 250ms
@@ -270,9 +276,9 @@ public void takeLastTimedWithZeroCapacity() {
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onCompleted(); // T: 1250ms
-        
+
         inOrder.verify(o, times(1)).onCompleted();
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
index 988ffa062e..266d631193 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,11 +15,12 @@
  */
 package rx.operators;
 
-import java.util.concurrent.TimeUnit;
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 import static rx.operators.OperationTake.*;
 
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
@@ -227,98 +228,98 @@ public void run() {
             return s;
         }
     }
-    
+
     @Test
     public void testTakeTimed() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(4);
-        
+
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
         inOrder.verify(o).onNext(3);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onNext(4);
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testTakeTimedErrorBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onError(new CustomException());
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(4);
-        
+
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
         inOrder.verify(o).onNext(3);
         inOrder.verify(o).onError(any(CustomException.class));
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(4);
     }
-    
+
     @Test
     public void testTakeTimedErrorAfterTime() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
-        
+
         Observable result = source.take(1, TimeUnit.SECONDS, scheduler);
-        
+
         Observer o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(4);
         source.onError(new CustomException());
-        
+
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
         inOrder.verify(o).onNext(3);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onNext(4);
         verify(o, never()).onError(any(CustomException.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
index c5182a71ba..a6425b2157 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
index 830dd59b33..2c7631f2c5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
index 682f030529..187fdf0d04 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
index c71ade0166..d2275eef8f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
index 833d2060ec..08172de564 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.Arrays;
+
 import org.junit.Test;
 import org.mockito.InOrder;
-import static org.mockito.Mockito.*;
+
 import rx.Observable;
 import rx.Observer;
 import rx.subjects.PublishSubject;
@@ -30,7 +34,7 @@ public class OperationTimeoutTest {
     public void testTimeoutSelectorNormal1() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
@@ -44,34 +48,34 @@ public Observable call() {
                 return timeout;
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         timeout.onNext(1);
-        
+
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
         inOrder.verify(o).onNext(3);
         inOrder.verify(o).onNext(100);
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
-    
+
     @Test
     public void testTimeoutSelectorTimeoutFirst() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
@@ -85,28 +89,28 @@ public Observable call() {
                 return timeout;
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         timeout.onNext(1);
-        
+
         inOrder.verify(o).onNext(100);
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
-    
+
     @Test
     public void testTimeoutSelectorFirstThrows() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
@@ -120,24 +124,25 @@ public Observable call() {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        
+
     }
+
     @Test
     public void testTimeoutSelectorSubsequentThrows() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
@@ -151,28 +156,28 @@ public Observable call() {
                 return timeout;
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         source.onNext(1);
 
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onCompleted();
-        
+
     }
-    
+
     @Test
     public void testTimeoutSelectorFirstObservableThrows() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
@@ -183,31 +188,32 @@ public Observable call(Integer t1) {
         Func0> firstTimeoutFunc = new Func0>() {
             @Override
             public Observable call() {
-                return Observable.error(new OperationReduceTest.CustomException());
+                return Observable. error(new OperationReduceTest.CustomException());
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        
+
     }
+
     @Test
     public void testTimeoutSelectorSubsequentObservableThrows() {
         PublishSubject source = PublishSubject.create();
         final PublishSubject timeout = PublishSubject.create();
-        
+
         Func1> timeoutFunc = new Func1>() {
             @Override
             public Observable call(Integer t1) {
-                return Observable.error(new OperationReduceTest.CustomException());
+                return Observable. error(new OperationReduceTest.CustomException());
             }
         };
 
@@ -217,20 +223,20 @@ public Observable call() {
                 return timeout;
             }
         };
-        
+
         Observable other = Observable.from(Arrays.asList(100));
-        
+
         @SuppressWarnings("unchecked")
         Observer o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         source.onNext(1);
 
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
         verify(o, never()).onCompleted();
-        
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
index 26521c7265..f586801c79 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
@@ -15,13 +15,17 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.concurrent.TimeUnit;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.*;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
@@ -31,28 +35,31 @@ public class OperationTimerTest {
     @Mock
     Observer observer;
     TestScheduler s;
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
         s = new TestScheduler();
     }
+
     @Test
     public void testTimerOnce() {
         Observable.timer(100, TimeUnit.MILLISECONDS, s).subscribe(observer);
         s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-        
+
         verify(observer, times(1)).onNext(0L);
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testTimerPeriodically() {
         Subscription c = Observable.timer(100, 100, TimeUnit.MILLISECONDS, s).subscribe(observer);
         s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-        
+
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onNext(0L);
-        
+
         s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(1L);
 
@@ -61,11 +68,11 @@ public void testTimerPeriodically() {
 
         s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, times(1)).onNext(3L);
-        
+
         c.unsubscribe();
         s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, never()).onNext(any());
-        
+
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java
index 90baedd3dc..b7d2c27917 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimestampTest.java
@@ -15,13 +15,17 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.concurrent.TimeUnit;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import static org.mockito.Mockito.*;
 import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.schedulers.TestScheduler;
@@ -31,55 +35,56 @@
 public class OperationTimestampTest {
     @Mock
     Observer observer;
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     @Test
     public void timestampWithScheduler() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
         Observable> m = source.timestamp(scheduler);
         m.subscribe(observer);
-        
+
         source.onNext(1);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         source.onNext(2);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         source.onNext(3);
-        
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         inOrder.verify(observer, times(1)).onNext(new Timestamped(0, 1));
         inOrder.verify(observer, times(1)).onNext(new Timestamped(100, 2));
         inOrder.verify(observer, times(1)).onNext(new Timestamped(200, 3));
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
+
     @Test
     public void timestampWithScheduler2() {
         TestScheduler scheduler = new TestScheduler();
-        
+
         PublishSubject source = PublishSubject.create();
         Observable> m = source.timestamp(scheduler);
         m.subscribe(observer);
-        
+
         source.onNext(1);
         source.onNext(2);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         source.onNext(3);
-        
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         inOrder.verify(observer, times(1)).onNext(new Timestamped(0, 1));
         inOrder.verify(observer, times(1)).onNext(new Timestamped(0, 2));
         inOrder.verify(observer, times(1)).onNext(new Timestamped(200, 3));
-        
+
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
index ffaf775f8b..83ae1bfb42 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java b/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java
index b40dd9b62b..4d63e98d2e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
index f35d555a34..c5abe311f8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,13 +15,18 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import org.junit.Test;
+
 import org.junit.Before;
-import org.mockito.*;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.util.functions.Func0;
@@ -31,11 +36,12 @@
 public class OperationToMapTest {
     @Mock
     Observer objectObserver;
-    
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     Func1 lengthFunc = new Func1() {
         @Override
         public Integer call(String t1) {
@@ -48,13 +54,13 @@ public String call(String t1) {
             return t1 + t1;
         }
     };
+
     @Test
     public void testToMap() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
 
         Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc));
-        
+
         Map expected = new HashMap();
         expected.put(1, "a");
         expected.put(2, "bb");
@@ -71,9 +77,9 @@ public void testToMap() {
     @Test
     public void testToMapWithValueSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
+
         Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, duplicate));
-        
+
         Map expected = new HashMap();
         expected.put(1, "aa");
         expected.put(2, "bbbb");
@@ -87,10 +93,10 @@ public void testToMapWithValueSelector() {
         verify(objectObserver, times(1)).onCompleted();
     }
 
-    @Test 
+    @Test
     public void testToMapWithError() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
+
         Func1 lengthFuncErr = new Func1() {
             @Override
             public Integer call(String t1) {
@@ -101,15 +107,15 @@ public Integer call(String t1) {
             }
         };
         Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFuncErr));
-        
+
         Map expected = new HashMap();
         expected.put(1, "a");
         expected.put(2, "bb");
         expected.put(3, "ccc");
         expected.put(4, "dddd");
-        
+
         mapped.subscribe(objectObserver);
-        
+
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
         verify(objectObserver, times(1)).onError(any(Throwable.class));
@@ -119,7 +125,7 @@ public Integer call(String t1) {
     @Test
     public void testToMapWithErrorInValueSelector() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
+
         Func1 duplicateErr = new Func1() {
             @Override
             public String call(String t1) {
@@ -129,17 +135,17 @@ public String call(String t1) {
                 return t1 + t1;
             }
         };
-        
+
         Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, duplicateErr));
-        
+
         Map expected = new HashMap();
         expected.put(1, "aa");
         expected.put(2, "bbbb");
         expected.put(3, "cccccc");
         expected.put(4, "dddddddd");
-        
+
         mapped.subscribe(objectObserver);
-        
+
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
         verify(objectObserver, times(1)).onError(any(Throwable.class));
@@ -149,7 +155,7 @@ public String call(String t1) {
     @Test
     public void testToMapWithFactory() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
+
         Func0> mapFactory = new Func0>() {
             @Override
             public Map call() {
@@ -161,15 +167,15 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
                 };
             }
         };
-        
+
         Func1 lengthFunc = new Func1() {
             @Override
             public Integer call(String t1) {
                 return t1.length();
             }
         };
-        Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions.identity(), mapFactory));
-        
+        Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions. identity(), mapFactory));
+
         Map expected = new LinkedHashMap();
         expected.put(2, "bb");
         expected.put(3, "ccc");
@@ -181,25 +187,26 @@ public Integer call(String t1) {
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
     }
+
     @Test
     public void testToMapWithErrorThrowingFactory() {
         Observable source = Observable.from("a", "bb", "ccc", "dddd");
-        
+
         Func0> mapFactory = new Func0>() {
             @Override
             public Map call() {
                 throw new RuntimeException("Forced failure");
             }
         };
-        
+
         Func1 lengthFunc = new Func1() {
             @Override
             public Integer call(String t1) {
                 return t1.length();
             }
         };
-        Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions.identity(), mapFactory));
-        
+        Observable> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions. identity(), mapFactory));
+
         Map expected = new LinkedHashMap();
         expected.put(2, "bb");
         expected.put(3, "ccc");
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
index 478f5f1da8..2499ae70e1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 package rx.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -22,10 +26,12 @@
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import org.junit.Test;
+
 import org.junit.Before;
-import org.mockito.*;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
 import rx.Observable;
 import rx.Observer;
 import rx.operators.OperationToMultimap.DefaultMultimapCollectionFactory;
@@ -33,14 +39,16 @@
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 import rx.util.functions.Functions;
+
 public class OperationToMultimapTest {
     @Mock
     Observer objectObserver;
-    
+
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
     }
+
     Func1 lengthFunc = new Func1() {
         @Override
         public Integer call(String t1) {
@@ -53,13 +61,13 @@ public String call(String t1) {
             return t1 + t1;
         }
     };
+
     @Test
     public void testToMultimap() {
         Observable source = Observable.from("a", "b", "cc", "dd");
-        
 
         Observable>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc));
-        
+
         Map> expected = new HashMap>();
         expected.put(1, Arrays.asList("a", "b"));
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -69,14 +77,14 @@ public void testToMultimap() {
         verify(objectObserver, never()).onError(any(Throwable.class));
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
-    }    
+    }
+
     @Test
     public void testToMultimapWithValueSelector() {
         Observable source = Observable.from("a", "b", "cc", "dd");
-        
 
         Observable>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc, duplicate));
-        
+
         Map> expected = new HashMap>();
         expected.put(1, Arrays.asList("aa", "bb"));
         expected.put(2, Arrays.asList("cccc", "dddd"));
@@ -87,10 +95,11 @@ public void testToMultimapWithValueSelector() {
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
     }
+
     @Test
     public void testToMultimapWithMapFactory() {
         Observable source = Observable.from("a", "b", "cc", "dd", "eee", "fff");
-        
+
         Func0>> mapFactory = new Func0>>() {
             @Override
             public Map> call() {
@@ -104,10 +113,10 @@ protected boolean removeEldestEntry(Map.Entry> eldes
         };
 
         Observable>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(source, 
-                        lengthFunc, Functions.identity(), 
+                OperationToMultimap.toMultimap(source,
+                        lengthFunc, Functions. identity(),
                         mapFactory, new DefaultMultimapCollectionFactory()));
-        
+
         Map> expected = new HashMap>();
         expected.put(2, Arrays.asList("cc", "dd"));
         expected.put(3, Arrays.asList("eee", "fff"));
@@ -117,11 +126,12 @@ protected boolean removeEldestEntry(Map.Entry> eldes
         verify(objectObserver, never()).onError(any(Throwable.class));
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
-    }  
+    }
+
     @Test
     public void testToMultimapWithCollectionFactory() {
         Observable source = Observable.from("cc", "dd", "eee", "eee");
-        
+
         Func1> collectionFactory = new Func1>() {
 
             @Override
@@ -136,9 +146,9 @@ public Collection call(Integer t1) {
 
         Observable>> mapped = Observable.create(
                 OperationToMultimap.toMultimap(
-                source, lengthFunc, Functions.identity(),
+                        source, lengthFunc, Functions. identity(),
                         new DefaultToMultimapFactory(), collectionFactory));
-        
+
         Map> expected = new HashMap>();
         expected.put(2, Arrays.asList("cc", "dd"));
         expected.put(3, new HashSet(Arrays.asList("eee")));
@@ -148,11 +158,12 @@ public Collection call(Integer t1) {
         verify(objectObserver, never()).onError(any(Throwable.class));
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
-    } 
+    }
+
     @Test
     public void testToMultimapWithError() {
         Observable source = Observable.from("a", "b", "cc", "dd");
-        
+
         Func1 lengthFuncErr = new Func1() {
             @Override
             public Integer call(String t1) {
@@ -164,7 +175,7 @@ public Integer call(String t1) {
         };
 
         Observable>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFuncErr));
-        
+
         Map> expected = new HashMap>();
         expected.put(1, Arrays.asList("a", "b"));
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -174,11 +185,12 @@ public Integer call(String t1) {
         verify(objectObserver, times(1)).onError(any(Throwable.class));
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
-    }    
+    }
+
     @Test
     public void testToMultimapWithErrorInValueSelector() {
         Observable source = Observable.from("a", "b", "cc", "dd");
-        
+
         Func1 duplicateErr = new Func1() {
             @Override
             public String call(String t1) {
@@ -190,7 +202,7 @@ public String call(String t1) {
         };
 
         Observable>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc, duplicateErr));
-        
+
         Map> expected = new HashMap>();
         expected.put(1, Arrays.asList("aa", "bb"));
         expected.put(2, Arrays.asList("cccc", "dddd"));
@@ -201,11 +213,11 @@ public String call(String t1) {
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
     }
-    
+
     @Test
     public void testToMultimapWithMapThrowingFactory() {
         Observable source = Observable.from("a", "b", "cc", "dd", "eee", "fff");
-        
+
         Func0>> mapFactory = new Func0>>() {
             @Override
             public Map> call() {
@@ -214,8 +226,8 @@ public Map> call() {
         };
 
         Observable>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(source, lengthFunc, Functions.identity(), mapFactory));
-        
+                OperationToMultimap.toMultimap(source, lengthFunc, Functions. identity(), mapFactory));
+
         Map> expected = new HashMap>();
         expected.put(2, Arrays.asList("cc", "dd"));
         expected.put(3, Arrays.asList("eee", "fff"));
@@ -225,11 +237,12 @@ public Map> call() {
         verify(objectObserver, times(1)).onError(any(Throwable.class));
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
-    }  
+    }
+
     @Test
     public void testToMultimapWithThrowingCollectionFactory() {
         Observable source = Observable.from("cc", "cc", "eee", "eee");
-        
+
         Func1> collectionFactory = new Func1>() {
 
             @Override
@@ -244,8 +257,8 @@ public Collection call(Integer t1) {
 
         Observable>> mapped = Observable.create(
                 OperationToMultimap.toMultimap(
-                source, lengthFunc, Functions.identity(), new DefaultToMultimapFactory(), collectionFactory));
-        
+                        source, lengthFunc, Functions. identity(), new DefaultToMultimapFactory(), collectionFactory));
+
         Map> expected = new HashMap>();
         expected.put(2, Arrays.asList("cc", "dd"));
         expected.put(3, Collections.singleton("eee"));
@@ -255,5 +268,5 @@ public Collection call(Integer t1) {
         verify(objectObserver, times(1)).onError(any(Throwable.class));
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
-    } 
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
index dcc6efcc6a..691fcdd23d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
index 16ad47f372..0cfb616e4b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableIterableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -43,7 +43,7 @@ public void testIterable() {
         verify(aObserver, Mockito.never()).onError(any(Throwable.class));
         verify(aObserver, times(1)).onCompleted();
     }
-    
+
     @Test
     public void testIterableScheduled() {
         Observable observable = Observable.create(toObservableIterable(Arrays. asList("one", "two", "three"), Schedulers.currentThread()));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java
index 767c05acfb..110721235f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableListTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableSortedListTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableSortedListTest.java
index 8c572a31b6..fe1e8cc58b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableSortedListTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableSortedListTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
index 42d31cea9a..ca67b71c80 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,13 +15,9 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static rx.operators.OperationUsing.using;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+import static rx.operators.OperationUsing.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index 4886ed1661..b4b555ee5f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -16,6 +16,8 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 import static rx.operators.OperationWindow.*;
 
 import java.util.ArrayList;
@@ -24,7 +26,6 @@
 
 import org.junit.Before;
 import org.junit.Test;
-import static org.mockito.Mockito.*;
 
 import rx.Observable;
 import rx.Observer;
@@ -52,15 +53,17 @@ private static  List> toLists(Observable> observables)
         final List> lists = new ArrayList>();
         Observable.concat(observables.map(new Func1, Observable>>() {
             @Override
-            public Observable> call(Observable xs) { return xs.toList(); }
+            public Observable> call(Observable xs) {
+                return xs.toList();
+            }
         }))
                 .toBlockingObservable()
                 .forEach(new Action1>() {
-            @Override
-            public void call(List xs) {
-                lists.add(xs);
-            }
-        });
+                    @Override
+                    public void call(List xs) {
+                        lists.add(xs);
+                    }
+                });
         return lists;
     }
 
@@ -90,7 +93,7 @@ public void testSkipAndCountGaplessEindows() {
 
     @Test
     public void testOverlappingWindows() {
-        Observable subject = Observable.from(new String[]{"zero", "one", "two", "three", "four", "five"}, Schedulers.currentThread());
+        Observable subject = Observable.from(new String[] { "zero", "one", "two", "three", "four", "five" }, Schedulers.currentThread());
         Observable> windowed = Observable.create(window(subject, 3, 1));
 
         List> windows = toLists(windowed);
@@ -323,6 +326,7 @@ public void onNext(String args) {
             }
         };
     }
+
     @Test
     public void testWindowViaObservableNormal1() {
         PublishSubject source = PublishSubject.create();
@@ -330,16 +334,16 @@ public void testWindowViaObservableNormal1() {
 
         @SuppressWarnings("unchecked")
         final Observer o = mock(Observer.class);
-        
+
         final List> values = new ArrayList>();
-        
+
         Observer> wo = new Observer>() {
             @Override
             public void onNext(Observable args) {
                 @SuppressWarnings("unchecked")
                 final Observer mo = mock(Observer.class);
                 values.add(mo);
-                
+
                 args.subscribe(mo);
             }
 
@@ -353,7 +357,7 @@ public void onCompleted() {
                 o.onCompleted();
             }
         };
-        
+
         source.window(boundary).subscribe(wo);
 
         int n = 30;
@@ -366,7 +370,7 @@ public void onCompleted() {
         source.onCompleted();
 
         assertEquals(n / 3, values.size());
-        
+
         int j = 0;
         for (Observer mo : values) {
             for (int i = 0; i < 3; i++) {
@@ -376,11 +380,11 @@ public void onCompleted() {
             verify(mo, never()).onError(any(Throwable.class));
             j += 3;
         }
-        
+
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testWindowViaObservableBoundaryCompletes() {
         PublishSubject source = PublishSubject.create();
@@ -388,16 +392,16 @@ public void testWindowViaObservableBoundaryCompletes() {
 
         @SuppressWarnings("unchecked")
         final Observer o = mock(Observer.class);
-        
+
         final List> values = new ArrayList>();
-        
+
         Observer> wo = new Observer>() {
             @Override
             public void onNext(Observable args) {
                 @SuppressWarnings("unchecked")
                 final Observer mo = mock(Observer.class);
                 values.add(mo);
-                
+
                 args.subscribe(mo);
             }
 
@@ -411,7 +415,7 @@ public void onCompleted() {
                 o.onCompleted();
             }
         };
-        
+
         source.window(boundary).subscribe(wo);
 
         int n = 30;
@@ -424,7 +428,7 @@ public void onCompleted() {
         boundary.onCompleted();
 
         assertEquals(n / 3, values.size());
-        
+
         int j = 0;
         for (Observer mo : values) {
             for (int i = 0; i < 3; i++) {
@@ -434,11 +438,11 @@ public void onCompleted() {
             verify(mo, never()).onError(any(Throwable.class));
             j += 3;
         }
-        
+
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testWindowViaObservableBoundaryThrows() {
         PublishSubject source = PublishSubject.create();
@@ -446,16 +450,16 @@ public void testWindowViaObservableBoundaryThrows() {
 
         @SuppressWarnings("unchecked")
         final Observer o = mock(Observer.class);
-        
+
         final List> values = new ArrayList>();
-        
+
         Observer> wo = new Observer>() {
             @Override
             public void onNext(Observable args) {
                 @SuppressWarnings("unchecked")
                 final Observer mo = mock(Observer.class);
                 values.add(mo);
-                
+
                 args.subscribe(mo);
             }
 
@@ -469,7 +473,7 @@ public void onCompleted() {
                 o.onCompleted();
             }
         };
-        
+
         source.window(boundary).subscribe(wo);
 
         source.onNext(0);
@@ -479,18 +483,18 @@ public void onCompleted() {
         boundary.onError(new OperationReduceTest.CustomException());
 
         assertEquals(1, values.size());
-        
+
         Observer mo = values.get(0);
-        
+
         verify(mo).onNext(0);
         verify(mo).onNext(1);
         verify(mo).onNext(2);
         verify(mo).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
-    
+
     @Test
     public void testWindowViaObservableourceThrows() {
         PublishSubject source = PublishSubject.create();
@@ -498,16 +502,16 @@ public void testWindowViaObservableourceThrows() {
 
         @SuppressWarnings("unchecked")
         final Observer o = mock(Observer.class);
-        
+
         final List> values = new ArrayList>();
-        
+
         Observer> wo = new Observer>() {
             @Override
             public void onNext(Observable args) {
                 @SuppressWarnings("unchecked")
                 final Observer mo = mock(Observer.class);
                 values.add(mo);
-                
+
                 args.subscribe(mo);
             }
 
@@ -521,7 +525,7 @@ public void onCompleted() {
                 o.onCompleted();
             }
         };
-        
+
         source.window(boundary).subscribe(wo);
 
         source.onNext(0);
@@ -531,14 +535,14 @@ public void onCompleted() {
         source.onError(new OperationReduceTest.CustomException());
 
         assertEquals(1, values.size());
-        
+
         Observer mo = values.get(0);
-        
+
         verify(mo).onNext(0);
         verify(mo).onNext(1);
         verify(mo).onNext(2);
         verify(mo).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTest.java b/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
index 6bd8b36b62..b1970a8a07 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationZipTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,14 +15,9 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static rx.operators.OperationZip.zip;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.operators.OperationZip.*;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -45,32 +40,34 @@
 import rx.util.functions.Functions;
 
 public class OperationZipTest {
-	Func2 concat2Strings; 
+    Func2 concat2Strings;
     PublishSubject s1;
-	PublishSubject s2;
-	Observable zipped;
-	
-	Observer observer;
-	InOrder inOrder;
-	@Before 
-	@SuppressWarnings("unchecked")
-	public void setUp() {
-		concat2Strings = new Func2() {
+    PublishSubject s2;
+    Observable zipped;
+
+    Observer observer;
+    InOrder inOrder;
+
+    @Before
+    @SuppressWarnings("unchecked")
+    public void setUp() {
+        concat2Strings = new Func2() {
             @Override
             public String call(String t1, String t2) {
                 return t1 + "-" + t2;
             }
-        }; 
-        
-		s1 = PublishSubject.create();
-		s2 = PublishSubject.create();
-		zipped = Observable.zip(s1, s2, concat2Strings);
-		
-		observer = mock(Observer.class);
-		inOrder = inOrder(observer);
-		
-		zipped.subscribe(observer);
-	}
+        };
+
+        s1 = PublishSubject.create();
+        s2 = PublishSubject.create();
+        zipped = Observable.zip(s1, s2, concat2Strings);
+
+        observer = mock(Observer.class);
+        inOrder = inOrder(observer);
+
+        zipped.subscribe(observer);
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void testCollectionSizeDifferentThanFunction() {
@@ -160,7 +157,6 @@ public void testZippingDifferentLengthObservableSequences2() {
 
     }
 
-    
     Func2 zipr2 = new Func2() {
 
         @Override
@@ -177,6 +173,7 @@ public String call(Object t1, Object t2, Object t3) {
         }
 
     };
+
     /**
      * Testing internal private logic due to the complexity so I want to use TDD to test as a I build it rather than relying purely on the overall functionality expected by the public methods.
      */
@@ -188,7 +185,7 @@ public void testAggregatorSimple() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -225,7 +222,7 @@ public void testAggregatorDifferentSizedResultsWithOnComplete() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -255,8 +252,8 @@ public void testAggregateMultipleTypes() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
-        Observable.zip(r1, r2, zipr2).subscribe(aObserver);        
+
+        Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
         r1.onNext("hello");
@@ -286,13 +283,13 @@ public void testAggregate3Types() {
         PublishSubject> r3 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
-        Observable.zip(r1, r2, r3, zipr3).subscribe(aObserver);        
+
+        Observable.zip(r1, r2, r3, zipr3).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
         r1.onNext("hello");
         r2.onNext(2);
-        r3.onNext(Arrays.asList( 5, 6, 7 ));
+        r3.onNext(Arrays.asList(5, 6, 7));
 
         verify(aObserver, never()).onError(any(Throwable.class));
         verify(aObserver, never()).onCompleted();
@@ -307,7 +304,7 @@ public void testAggregatorsWithDifferentSizesAndTiming() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -344,7 +341,7 @@ public void testAggregatorError() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -373,7 +370,7 @@ public void testAggregatorUnsubscribe() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Subscription subscription = Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -402,7 +399,7 @@ public void testAggregatorEarlyCompletion() {
         PublishSubject r2 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
         Observer aObserver = mock(Observer.class);
-        
+
         Observable.zip(r1, r2, zipr2).subscribe(aObserver);
 
         /* simulate the Observables pushing data into the aggregator */
@@ -473,7 +470,7 @@ public void testOnNextExceptionInvokesOnError() {
 
         verify(aObserver, times(1)).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testOnFirstCompletion() {
         PublishSubject oA = PublishSubject.create();
@@ -502,7 +499,7 @@ public void testOnFirstCompletion() {
         oA.onCompleted();
 
         // SHOULD ONCOMPLETE BE EMITTED HERE INSTEAD OF WAITING
-       // FOR B3, B4, B5 TO BE EMITTED?
+        // FOR B3, B4, B5 TO BE EMITTED?
 
         oB.onNext("b3");
         oB.onNext("b4");
@@ -524,7 +521,7 @@ public void testOnFirstCompletion() {
         // we should receive nothing else despite oB continuing after oA completed
         io.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void testOnErrorTermination() {
         PublishSubject oA = PublishSubject.create();
@@ -577,8 +574,6 @@ public String call(String t1, String t2) {
             }
         };
     }
-    
-    
 
     private Func2 getDivideZipr() {
         Func2 zipr = new Func2() {
@@ -680,89 +675,91 @@ public Subscription onSubscribe(Observer Observer) {
         }
 
     }
-    
+
     @Test
-	public void testFirstCompletesThenSecondInfinite() {
-		s1.onNext("a");
-		s1.onNext("b");
-		s1.onCompleted();
-		s2.onNext("1");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s2.onNext("2");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-	
-	@Test
-	public void testSecondInfiniteThenFirstCompletes() {
-		s2.onNext("1");
-		s2.onNext("2");
-		s1.onNext("a");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s1.onNext("b");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		s1.onCompleted();
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-	
-	@Test
-	public void testSecondCompletesThenFirstInfinite() {
-		s2.onNext("1");
-		s2.onNext("2");
-		s2.onCompleted();
-		s1.onNext("a");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s1.onNext("b");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-
-	@Test
-	public void testFirstInfiniteThenSecondCompletes() {
-		s1.onNext("a");
-		s1.onNext("b");
-		s2.onNext("1");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s2.onNext("2");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		s2.onCompleted();
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-	@Test
-	public void testFirstFails() {
-		s2.onNext("a");
-		s1.onError(new RuntimeException("Forced failure"));
-
-		inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
-
-		s2.onNext("b");
-		s1.onNext("1");
-		s1.onNext("2");
-		
-		inOrder.verify(observer, never()).onCompleted();
-		inOrder.verify(observer, never()).onNext(any(String.class));
-		inOrder.verifyNoMoreInteractions();
-	}
-	@Test
-	public void testSecondFails() {
-		s1.onNext("a");
-		s1.onNext("b");
-		s2.onError(new RuntimeException("Forced failure"));
-
-		inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
-		
-		s2.onNext("1");
-		s2.onNext("2");
-		
-		inOrder.verify(observer, never()).onCompleted();
-		inOrder.verify(observer, never()).onNext(any(String.class));
-		inOrder.verifyNoMoreInteractions();
-	}
-    
+    public void testFirstCompletesThenSecondInfinite() {
+        s1.onNext("a");
+        s1.onNext("b");
+        s1.onCompleted();
+        s2.onNext("1");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s2.onNext("2");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testSecondInfiniteThenFirstCompletes() {
+        s2.onNext("1");
+        s2.onNext("2");
+        s1.onNext("a");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s1.onNext("b");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        s1.onCompleted();
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testSecondCompletesThenFirstInfinite() {
+        s2.onNext("1");
+        s2.onNext("2");
+        s2.onCompleted();
+        s1.onNext("a");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s1.onNext("b");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testFirstInfiniteThenSecondCompletes() {
+        s1.onNext("a");
+        s1.onNext("b");
+        s2.onNext("1");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s2.onNext("2");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        s2.onCompleted();
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testFirstFails() {
+        s2.onNext("a");
+        s1.onError(new RuntimeException("Forced failure"));
+
+        inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
+
+        s2.onNext("b");
+        s1.onNext("1");
+        s1.onNext("2");
+
+        inOrder.verify(observer, never()).onCompleted();
+        inOrder.verify(observer, never()).onNext(any(String.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testSecondFails() {
+        s1.onNext("a");
+        s1.onNext("b");
+        s2.onError(new RuntimeException("Forced failure"));
+
+        inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
+
+        s2.onNext("1");
+        s2.onNext("2");
+
+        inOrder.verify(observer, never()).onCompleted();
+        inOrder.verify(observer, never()).onNext(any(String.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
     @Test
     public void testZipIterableSameSize() {
         PublishSubject r1 = PublishSubject.create();
@@ -771,22 +768,23 @@ public void testZipIterableSameSize() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList("1", "2", "3");
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onNext("three-");
         r1.onCompleted();
-        
+
         io.verify(o).onNext("one-1");
         io.verify(o).onNext("two-2");
         io.verify(o).onNext("three-3");
         io.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
+
     @Test
     public void testZipIterableEmptyFirstSize() {
         PublishSubject r1 = PublishSubject.create();
@@ -795,17 +793,18 @@ public void testZipIterableEmptyFirstSize() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList("1", "2", "3");
-        
+
         r1.zip(r2, zipr2).subscribe(o);
 
         r1.onCompleted();
-        
+
         io.verify(o).onCompleted();
 
         verify(o, never()).onNext(any(String.class));
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
+
     @Test
     public void testZipIterableEmptySecond() {
         PublishSubject r1 = PublishSubject.create();
@@ -814,19 +813,20 @@ public void testZipIterableEmptySecond() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList();
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onNext("three-");
         r1.onCompleted();
-        
+
         io.verify(o).onCompleted();
-        
+
         verify(o, never()).onNext(any(String.class));
         verify(o, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testZipIterableFirstShorter() {
         PublishSubject r1 = PublishSubject.create();
@@ -835,21 +835,21 @@ public void testZipIterableFirstShorter() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList("1", "2", "3");
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onCompleted();
-        
+
         io.verify(o).onNext("one-1");
         io.verify(o).onNext("two-2");
         io.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
-    
+
     @Test
     public void testZipIterableSecondShorter() {
         PublishSubject r1 = PublishSubject.create();
@@ -858,21 +858,22 @@ public void testZipIterableSecondShorter() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList("1", "2");
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onNext("three-");
         r1.onCompleted();
-        
+
         io.verify(o).onNext("one-1");
         io.verify(o).onNext("two-2");
         io.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
+
     @Test
     public void testZipIterableFirstThrows() {
         PublishSubject r1 = PublishSubject.create();
@@ -881,21 +882,21 @@ public void testZipIterableFirstThrows() {
         InOrder io = inOrder(o);
 
         Iterable r2 = Arrays.asList("1", "2", "3");
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onError(new OperationReduceTest.CustomException());
-        
+
         io.verify(o).onNext("one-1");
         io.verify(o).onNext("two-2");
         io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onCompleted();
-        
+
     }
-    
+
     @Test
     public void testZipIterableIteratorThrows() {
         PublishSubject r1 = PublishSubject.create();
@@ -909,19 +910,20 @@ public Iterator iterator() {
                 throw new OperationReduceTest.CustomException();
             }
         };
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onNext("two-");
         r1.onError(new OperationReduceTest.CustomException());
-        
+
         io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any(String.class));
-        
+
     }
+
     @Test
     public void testZipIterableHasNextThrows() {
         PublishSubject r1 = PublishSubject.create();
@@ -935,6 +937,7 @@ public void testZipIterableHasNextThrows() {
             public Iterator iterator() {
                 return new Iterator() {
                     int count;
+
                     @Override
                     public boolean hasNext() {
                         if (count == 0) {
@@ -953,23 +956,24 @@ public String next() {
                     public void remove() {
                         throw new UnsupportedOperationException("Not supported yet.");
                     }
-                    
+
                 };
             }
-            
+
         };
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onNext("one-");
         r1.onError(new OperationReduceTest.CustomException());
-        
+
         io.verify(o).onNext("one-1");
         io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onCompleted();
-        
+
     }
+
     @Test
     public void testZipIterableNextThrows() {
         PublishSubject r1 = PublishSubject.create();
@@ -983,6 +987,7 @@ public void testZipIterableNextThrows() {
             public Iterator iterator() {
                 return new Iterator() {
                     int count;
+
                     @Override
                     public boolean hasNext() {
                         return true;
@@ -997,20 +1002,20 @@ public String next() {
                     public void remove() {
                         throw new UnsupportedOperationException("Not supported yet.");
                     }
-                    
+
                 };
             }
-            
+
         };
-        
+
         r1.zip(r2, zipr2).subscribe(o);
-        
+
         r1.onError(new OperationReduceTest.CustomException());
-        
+
         io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-        
+
         verify(o, never()).onNext(any(String.class));
         verify(o, never()).onCompleted();
-        
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
index 23baf7652c..a1a82a77cc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,9 +15,7 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.*;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -29,90 +27,90 @@
 import rx.util.functions.Func2;
 
 /**
- * Systematically tests that when zipping an infinite and a finite Observable, 
+ * Systematically tests that when zipping an infinite and a finite Observable,
  * the resulting Observable is finite.
- *
+ * 
  */
 public class OperationZipTestCompletion {
-	Func2 concat2Strings;
-	
-	PublishSubject s1;
-	PublishSubject s2;
-	Observable zipped;
-	
-	Observer observer;
-	InOrder inOrder;
+    Func2 concat2Strings;
 
+    PublishSubject s1;
+    PublishSubject s2;
+    Observable zipped;
 
-	@Before @SuppressWarnings("unchecked")
-	public void setUp() {
-		concat2Strings = new Func2() {
+    Observer observer;
+    InOrder inOrder;
+
+    @Before
+    @SuppressWarnings("unchecked")
+    public void setUp() {
+        concat2Strings = new Func2() {
             @Override
             public String call(String t1, String t2) {
                 return t1 + "-" + t2;
             }
-        }; 
-        
-		s1 = PublishSubject.create();
-		s2 = PublishSubject.create();
-		zipped = Observable.zip(s1, s2, concat2Strings);
-		
-		observer = mock(Observer.class);
-		inOrder = inOrder(observer);
-		
-		zipped.subscribe(observer);
-	}
-	
-	@Test
-	public void testFirstCompletesThenSecondInfinite() {
-		s1.onNext("a");
-		s1.onNext("b");
-		s1.onCompleted();
-		s2.onNext("1");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s2.onNext("2");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-	
-	@Test
-	public void testSecondInfiniteThenFirstCompletes() {
-		s2.onNext("1");
-		s2.onNext("2");
-		s1.onNext("a");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s1.onNext("b");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		s1.onCompleted();
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
-	
-	@Test
-	public void testSecondCompletesThenFirstInfinite() {
-		s2.onNext("1");
-		s2.onNext("2");
-		s2.onCompleted();
-		s1.onNext("a");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s1.onNext("b");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
+        };
+
+        s1 = PublishSubject.create();
+        s2 = PublishSubject.create();
+        zipped = Observable.zip(s1, s2, concat2Strings);
+
+        observer = mock(Observer.class);
+        inOrder = inOrder(observer);
+
+        zipped.subscribe(observer);
+    }
+
+    @Test
+    public void testFirstCompletesThenSecondInfinite() {
+        s1.onNext("a");
+        s1.onNext("b");
+        s1.onCompleted();
+        s2.onNext("1");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s2.onNext("2");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testSecondInfiniteThenFirstCompletes() {
+        s2.onNext("1");
+        s2.onNext("2");
+        s1.onNext("a");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s1.onNext("b");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        s1.onCompleted();
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testSecondCompletesThenFirstInfinite() {
+        s2.onNext("1");
+        s2.onNext("2");
+        s2.onCompleted();
+        s1.onNext("a");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s1.onNext("b");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
 
-	@Test
-	public void testFirstInfiniteThenSecondCompletes() {
-		s1.onNext("a");
-		s1.onNext("b");
-		s2.onNext("1");
-		inOrder.verify(observer, times(1)).onNext("a-1");
-		s2.onNext("2");
-		inOrder.verify(observer, times(1)).onNext("b-2");
-		s2.onCompleted();
-		inOrder.verify(observer, times(1)).onCompleted();
-		inOrder.verifyNoMoreInteractions();
-	}
+    @Test
+    public void testFirstInfiniteThenSecondCompletes() {
+        s1.onNext("a");
+        s1.onNext("b");
+        s2.onNext("1");
+        inOrder.verify(observer, times(1)).onNext("a-1");
+        s2.onNext("2");
+        inOrder.verify(observer, times(1)).onNext("b-2");
+        s2.onCompleted();
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
 
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTesterTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTesterTest.java
index 645cea8e3b..b4fe6b12af 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTesterTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTesterTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java b/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
index bb317884bc..7e855779b3 100644
--- a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java
index f1c40c3674..a505cb18c6 100644
--- a/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SynchronizedObserverTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/TakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/TakeWhileTest.java
index 25e17ba13b..bf6697928d 100644
--- a/rxjava-core/src/test/java/rx/operators/TakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/TakeWhileTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/operators/TimeIntervalObserverTest.java b/rxjava-core/src/test/java/rx/operators/TimeIntervalObserverTest.java
index 29337619ff..d55102bbe7 100644
--- a/rxjava-core/src/test/java/rx/operators/TimeIntervalObserverTest.java
+++ b/rxjava-core/src/test/java/rx/operators/TimeIntervalObserverTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 07d430f625..0d141d55be 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -207,6 +207,7 @@ public String call(String s) {
 
     /**
      * The order of execution is nondeterministic.
+     * 
      * @throws InterruptedException
      */
     @SuppressWarnings("rawtypes")
diff --git a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
index 7958d87439..46e1ed35e4 100644
--- a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -29,7 +29,6 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Action1;
-import rx.util.functions.Func0;
 
 public class AsyncSubjectTest {
 
@@ -192,13 +191,13 @@ public void testEmptySubjectCompleted() {
     /**
      * Can receive timeout if subscribe never receives an onError/onCompleted ... which reveals a race condition.
      */
-    @Test(timeout=10000)
+    @Test(timeout = 10000)
     public void testSubscribeCompletionRaceCondition() {
         /*
          * With non-threadsafe code this fails most of the time on my dev laptop and is non-deterministic enough
          * to act as a unit test to the race conditions.
          * 
-         * With the synchronization code in place I can not get this to fail on my laptop. 
+         * With the synchronization code in place I can not get this to fail on my laptop.
          */
         for (int i = 0; i < 50; i++) {
             final AsyncSubject subject = AsyncSubject.create();
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index caca18204d..f5403ae231 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -185,6 +185,7 @@ public void testCompletedAfterErrorIsNotSent() {
         verify(aObserver, never()).onNext("two");
         verify(aObserver, never()).onCompleted();
     }
+
     @Test
     public void testCompletedAfterErrorIsNotSent2() {
         BehaviorSubject subject = BehaviorSubject.create("default");
@@ -210,7 +211,7 @@ public void testCompletedAfterErrorIsNotSent2() {
         verify(o2, never()).onNext(any());
         verify(o2, never()).onCompleted();
     }
-    
+
     @Test
     public void testCompletedAfterErrorIsNotSent3() {
         BehaviorSubject subject = BehaviorSubject.create("default");
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index 518d9b7b74..f78cf19726 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -30,7 +30,6 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Action1;
-import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
 public class PublishSubjectTest {
@@ -298,7 +297,6 @@ public void testReSubscribe() {
         s2.unsubscribe();
     }
 
-
     private final Throwable testException = new Throwable();
 
 }
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index e853944820..996682aaad 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -313,12 +313,12 @@ public void onNext(String v) {
         Subscription s2 = subject.observeOn(Schedulers.newThread()).subscribe(observer2);
 
         System.out.println("before waiting for one");
-        
+
         // wait until observer2 starts having replay occur
         oneReceived.await();
-        
+
         System.out.println("after waiting for one");
-        
+
         subject.onNext("three");
         // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet 
         assertEquals("three", lastValueForObserver1.get());
diff --git a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index e916ac9795..f8d752239b 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -15,10 +15,7 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.*;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
index 4d4cec95e1..454fc7f0b9 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
@@ -15,54 +15,60 @@
  */
 package rx.subscriptions;
 
+import static org.mockito.Mockito.*;
+import static rx.subscriptions.Subscriptions.*;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
-import static org.mockito.Mockito.*;
+
 import rx.Subscription;
-import static rx.subscriptions.Subscriptions.create;
 import rx.util.functions.Action0;
 
 public class RefCountSubscriptionTest {
     Action0 main;
     RefCountSubscription rcs;
+
     @Before
     public void before() {
         main = mock(Action0.class);
         rcs = new RefCountSubscription(create(main));
     }
+
     @Test
     public void testImmediateUnsubscribe() {
         InOrder inOrder = inOrder(main);
 
         rcs.unsubscribe();
-        
+
         inOrder.verify(main, times(1)).call();
-        
+
         rcs.unsubscribe();
 
         inOrder.verifyNoMoreInteractions();
     }
+
     @Test
     public void testRCSUnsubscribeBeforeClient() {
         InOrder inOrder = inOrder(main);
-        
+
         Subscription s = rcs.get();
-        
+
         rcs.unsubscribe();
-        
+
         inOrder.verify(main, never()).call();
-        
+
         s.unsubscribe();
-        
+
         inOrder.verify(main, times(1)).call();
-        
+
         rcs.unsubscribe();
         s.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
-        
+
     }
+
     @Test
     public void testMultipleClientsUnsubscribeFirst() {
         InOrder inOrder = inOrder(main);
@@ -74,16 +80,17 @@ public void testMultipleClientsUnsubscribeFirst() {
         inOrder.verify(main, never()).call();
         s2.unsubscribe();
         inOrder.verify(main, never()).call();
-        
+
         rcs.unsubscribe();
         inOrder.verify(main, times(1)).call();
 
         s1.unsubscribe();
         s2.unsubscribe();
         rcs.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
+
     @Test
     public void testMultipleClientsMainUnsubscribeFirst() {
         InOrder inOrder = inOrder(main);
@@ -96,13 +103,13 @@ public void testMultipleClientsMainUnsubscribeFirst() {
         s1.unsubscribe();
         inOrder.verify(main, never()).call();
         s2.unsubscribe();
-        
+
         inOrder.verify(main, times(1)).call();
 
         s1.unsubscribe();
         s2.unsubscribe();
         rcs.unsubscribe();
-        
+
         inOrder.verifyNoMoreInteractions();
     }
 }
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
index 9459242549..b75cb119a6 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
@@ -15,13 +15,8 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -127,7 +122,7 @@ public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscriptionConcur
         final CountDownLatch end = new CountDownLatch(count);
 
         final List threads = new ArrayList();
-        for (int i = 0 ; i < count ; i++) {
+        for (int i = 0; i < count; i++) {
             final Thread t = new Thread() {
                 @Override
                 public void run() {
@@ -167,7 +162,7 @@ public void concurrentSetSubscriptionShouldNotInterleave()
         final CountDownLatch end = new CountDownLatch(count);
 
         final List threads = new ArrayList();
-        for (int i = 0 ; i < count ; i++) {
+        for (int i = 0; i < count; i++) {
             final Subscription subscription = mock(Subscription.class);
             subscriptions.add(subscription);
 
@@ -192,7 +187,7 @@ public void run() {
         end.await();
         serialSubscription.unsubscribe();
 
-        for(final Subscription subscription : subscriptions) {
+        for (final Subscription subscription : subscriptions) {
             verify(subscription).unsubscribe();
         }
 
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
index abeab16833..86446650d7 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java
index 196a12e92f..1fba0f4f16 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservable.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -53,8 +53,7 @@ public static  void assertObservableEqualsBlocking(String message, Observable
 
     /**
      * Asserts that two {@link Observable}s are equal and returns an empty {@link Observable}. If
-     * they are not, an {@link Observable} is returned that calls onError with an
-     * {@link AssertionError} when subscribed to. If expected and actual
+     * they are not, an {@link Observable} is returned that calls onError with an {@link AssertionError} when subscribed to. If expected and actual
      * are null, they are considered equal.
      * 
      * @param message
@@ -70,8 +69,7 @@ public static  Observable assertObservableEquals(Observable expected
 
     /**
      * Asserts that two {@link Observable}s are equal and returns an empty {@link Observable}. If
-     * they are not, an {@link Observable} is returned that calls onError with an
-     * {@link AssertionError} when subscribed to with the given message. If expected
+     * they are not, an {@link Observable} is returned that calls onError with an {@link AssertionError} when subscribed to with the given message. If expected
      * and actual are null, they are considered equal.
      * 
      * @param message
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservableTest.java b/rxjava-core/src/test/java/rx/util/AssertObservableTest.java
index a67381e89f..aa23abcd2f 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservableTest.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
diff --git a/rxjava-core/src/test/java/rx/util/RangeTest.java b/rxjava-core/src/test/java/rx/util/RangeTest.java
index 297e7a769a..71a05625a5 100644
--- a/rxjava-core/src/test/java/rx/util/RangeTest.java
+++ b/rxjava-core/src/test/java/rx/util/RangeTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.

From 175ec269d32e7345c4fdf74be6dbda7d75c53b9c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 22:57:44 -0800
Subject: [PATCH 213/441] Alphabetize Observable.java
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It’s a huge class … alphabetized the methods to give rhyme-and-reason for where to place new operators and for navigating it.
---
 rxjava-core/src/main/java/rx/Observable.java | 11605 ++++++++---------
 1 file changed, 5801 insertions(+), 5804 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 9eae69b528..365b49e083 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -157,24 +157,22 @@
  */
 public class Observable {
 
-    private final static ConcurrentHashMap internalClassMap = new ConcurrentHashMap();
-
-    /**
-     * 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);
-
     }
 
+    /**
+     * Executed when 'subscribe' is invoked.
+     */
+    private final OnSubscribeFunc onSubscribe;
+
+    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
+
     /**
      * Observable with Function to execute when subscribed to.
      * 
    
@@ -189,1021 +187,828 @@ 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:
-     * 
      
-     * 
    1. It stores a reference to the Observer in a collection object, such as
-     * a {@code List} object.
      2. 
-     * 
    2. 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.
      3. 
-     * 
    
-     * 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.
+     * Given multiple Observables, return the one that first emits an item.
      * 
    
-     * 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}
+     * @param sources
+     *            Observable sources competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    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();
-        }
+    public static  Observable amb(Iterable> sources) {
+        return create(OperationAmb.amb(sources));
     }
 
     /**
-     * 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:
-     * 
      
-     * 
    1. It stores a reference to the Observer in a collection object, such as
-     * a {@code List} object.
      2. 
-     * 
    2. 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.
      3. 
-     * 
    
-     * 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.
+     * Given multiple Observables, return the one that first emits an item.
      * 
    
-     * 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}
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    public Subscription subscribe(Observer observer, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(observer);
+    public static  Observable amb(Observable o1, Observable o2) {
+        return create(OperationAmb.amb(o1, o2));
     }
 
     /**
-     * Protects against errors being thrown from Observer implementations and
-     * ensures onNext/onError/onCompleted contract compliance.
+     * Given multiple Observables, return the one that first emits an item.
      * 
    
-     * See https://github.com/Netflix/RxJava/issues/216 for a discussion on
-     * "Guideline 6.4: Protect calls to user code from within an operator"
+     * 
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    private Subscription protectivelyWrapAndSubscribe(Observer o) {
-        SafeObservableSubscription subscription = new SafeObservableSubscription();
-        return subscription.wrap(subscribe(new SafeObserver(subscription, o)));
+    public static  Observable amb(Observable o1, Observable o2, Observable o3) {
+        return create(OperationAmb.amb(o1, o2, o3));
     }
 
     /**
-     * Subscribe and ignore all events.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @return
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    public Subscription subscribe() {
-        return protectivelyWrapAndSubscribe(new Observer() {
-
-            @Override
-            public void onCompleted() {
-                // do nothing
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                // do nothing
-            }
-
-        });
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) {
+        return create(OperationAmb.amb(o1, o2, o3, o4));
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method
-     * in order to receive items and notifications from the Observable.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @param onNext
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    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) {
-                throw new OnErrorNotImplementedException(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                onNext.call(args);
-            }
-
-        });
-    }
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) {
+        return create(OperationAmb.amb(o1, o2, o3, o4, o5));
+    }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in
-     * order to receive items and notifications from the Observable.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @param onNext
-     * @param scheduler
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    public Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(onNext);
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) {
+        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6));
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in
-     * order to receive items and notifications from the Observable.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @param onNext
-     * @param onError
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    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) {
-                onError.call(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                onNext.call(args);
-            }
-
-        });
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) {
+        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7));
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in
-     * order to receive items and notifications from the Observable.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @param onNext
-     * @param onError
-     * @param scheduler
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
+     * @param o8
+     *            an observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(onNext, onError);
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) {
+        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in
-     * order to receive items and notifications from the Observable.
+     * Given multiple Observables, return the one that first emits an item.
+     * 
    
+     * 
      * 
-     * @param onNext
-     * @param onError
-     * @param onComplete
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            an Observable competing to react first
+     * @param o3
+     *            an Observable competing to react first
+     * @param o4
+     *            an Observable competing to react first
+     * @param o5
+     *            an Observable competing to react first
+     * @param o6
+     *            an Observable competing to react first
+     * @param o7
+     *            an Observable competing to react first
+     * @param o8
+     *            an Observable competing to react first
+     * @param o9
+     *            an Observable competing to react first
+     * @return an Observable that reflects whichever of the given Observables
+     *         reacted first
+     * @see RxJava Wiki: amb()
+     * @see MSDN: Observable.Amb
      */
-    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) {
-                onError.call(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                onNext.call(args);
-            }
-
-        });
+    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) {
+        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
     }
 
-    /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in
-     * order to receive items and notifications from the Observable.
-     * 
-     * @param onNext
-     * @param onError
-     * @param onComplete
-     * @param scheduler
-     * @return
-     * @see RxJava Wiki: onNext, onCompleted, and onError
-     */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
+    @Deprecated
+    public static Observable average(Observable source) {
+        return OperationAverage.average(source);
     }
 
     /**
-     * Hides the identity of this observable.
+     * Returns an Observable that emits the average of the Doubles emitted
+     * by the source Observable.
+     * 
    
+     * 
      * 
-     * @return an Observable hiding the identity of this Observable.
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits the average of all the Doubles emitted
+     *         by the source Observable as its single item
+     * @see RxJava Wiki: averageDouble()
+     * @see MSDN: Observable.Average
      */
-    public Observable asObservable() {
-        return create(new OperationAsObservable(this));
+    public static Observable averageDouble(Observable source) {
+        return OperationAverage.averageDoubles(source);
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that upon connection causes the
-     * source Observable to push results into the specified subject.
+     * Returns an Observable that computes the average of the Floats emitted by
+     * the source Observable.
+     * 
    
+     * 
      * 
-     * @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}
-     * @see RxJava Wiki: Observable.publish() and Observable.multicast()
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits the average of all the Floats emitted by
+     *         the source Observable as its single item
+     * @see RxJava Wiki: averageFloat()
+     * @see MSDN: Observable.Average
      */
-    public  ConnectableObservable multicast(Subject subject) {
-        return OperationMulticast.multicast(this, subject);
+    public static Observable averageFloat(Observable source) {
+        return OperationAverage.averageFloats(source);
     }
 
     /**
-     * Returns an observable sequence that contains the elements of a sequence
-     * produced by multicasting the source sequence within a selector function.
+     * Returns an Observable that computes the average of the Integers emitted
+     * by the source Observable.
+     * 
    
+     * 
      * 
-     * @param subjectFactory
-     *            the subject factory
-     * @param selector
-     *            the selector function which can use the multicasted
-     *            source sequence subject to the policies enforced by the
-     *            created subject
-     * @return the Observable sequence that contains the elements of a sequence
-     *         produced by multicasting the source sequence within a selector
-     *         function
-     * @see RxJava: Observable.publish() and Observable.multicast()
-     * @see MSDN: Observable.Multicast
+     * @param source
+     *            source observable to compute the average of
+     * @return an Observable that emits the average of all the Integers emitted
+     *         by the source Observable as its single item
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
+     * @see RxJava Wiki: averageInteger()
+     * @see MSDN: Observable.Average
      */
-    public  Observable multicast(
-            final Func0> subjectFactory,
-            final Func1, ? extends Observable> selector) {
-        return OperationMulticast.multicast(this, subjectFactory, selector);
+    public static Observable averageInteger(Observable source) {
+        return OperationAverage.average(source);
     }
 
     /**
-     * An Observable that never sends any information to an {@link Observer}.
-     * 
-     * This Observable is useful primarily for testing purposes.
+     * Returns an Observable that computes the average of the Longs emitted by
+     * the source Observable.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the type of item emitted by the Observable
+     * @param source
+     *            source Observable to compute the average of
+     * @return an Observable that emits the average of all the Longs emitted by
+     *         the source Observable as its single item
+     * @see RxJava Wiki: averageLong()
+     * @see MSDN: Observable.Average
      */
-    private static class NeverObservable extends Observable {
-        public NeverObservable() {
-            super(new OnSubscribeFunc() {
-
-                @Override
-                public Subscription onSubscribe(Observer t1) {
-                    return Subscriptions.empty();
-                }
-
-            });
-        }
+    public static Observable averageLong(Observable source) {
+        return OperationAverage.averageLongs(source);
     }
 
     /**
-     * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the type of item emitted by the Observable
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    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();
-                }
-
-            });
-        }
-
+    public static  Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction));
     }
 
     /**
-     * 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.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * 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 cancel the subscription
-     * @return an Observable that, when an {@link Observer} subscribes to it,
-     *         will execute the given function
-     * @see RxJava Wiki: create()
-     * @see MSDN: Observable.Create
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable create(OnSubscribeFunc func) {
-        return new Observable(func);
+    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction));
     }
 
     /**
-     * Returns an Observable that emits no items to the {@link Observer} and
-     * immediately invokes its {@link Observer#onCompleted onCompleted} method.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: empty()
-     * @see MSDN: Observable.Empty
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable empty() {
-        return from(new ArrayList());
+    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4,
+            Func4 combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction));
     }
 
     /**
-     * Returns an Observable that emits no items to the {@link Observer} and
-     * immediately invokes its {@link Observer#onCompleted onCompleted} method
-     * with the specified scheduler.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * 
+     * 
      * 
-     * @param scheduler
-     *            the scheduler to call the {@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 with the
-     *         specified scheduler
-     * @see RxJava Wiki: empty()
-     * @see MSDN: Observable.Empty Method (IScheduler)
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable empty(Scheduler scheduler) {
-        return Observable. empty().subscribeOn(scheduler);
+    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));
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the Observer subscribes to
-     * it.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: error()
-     * @see MSDN: Observable.Throw
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable error(Throwable exception) {
-        return new ThrowObservable(exception);
+    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));
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method with the specified scheduler.
-     * 
    
-     * 
-     * 
-     * @param exception
-     *            the particular error to report
-     * @param scheduler
-     *            the scheduler to call the {@link Observer#onError onError} method
-     * @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 with the specified
-     *         scheduler
-     * @see RxJava Wiki: error()
-     * @see MSDN: Observable.Throw
-     */
-    public static  Observable error(Throwable exception, Scheduler scheduler) {
-        return Observable. error(exception).subscribeOn(scheduler);
-    }
-
-    /**
-     * Converts an {@link Iterable} sequence into an Observable.
-     * 
    
-     * 
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * Note: the entire iterable sequence is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is 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
-     * @see RxJava Wiki: from()
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable from(Iterable iterable) {
-        return from(iterable, Schedulers.immediate());
+    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));
     }
 
     /**
-     * Converts an {@link Iterable} sequence into an Observable with the
-     * specified scheduler.
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * 
+     * 
      * 
-     * @param iterable
-     *            the source {@link Iterable} sequence
-     * @param scheduler
-     *            the scheduler to emit the items of the iterable
-     * @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 with the specified scheduler
-     * @see RxJava Wiki: from()
-     * @see MSDN: Observable.ToObservable
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param o8
+     *            the eighth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable from(Iterable iterable, Scheduler scheduler) {
-        return create(OperationToObservableIterable.toObservableIterable(iterable, scheduler));
+    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));
     }
 
     /**
-     * Converts an Array into an Observable that emits the items in the Array.
-     * 
    
-     * 
+     * Combines the given Observables, emitting an item that aggregates the
+     * latest values of each of the source Observables each time an item is
+     * received from any of the source Observables, where this aggregation is
+     * defined by a given function.
      * 
    
-     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
-     * the sequence before it completes.
+     * 
      * 
-     * @param items
-     *            the source array
-     * @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
-     * @see RxJava Wiki: from()
+     * @param o1
+     *            the first source Observable
+     * @param o2
+     *            the second source Observable
+     * @param o3
+     *            the third source Observable
+     * @param o4
+     *            the fourth source Observable
+     * @param o5
+     *            the fifth source Observable
+     * @param o6
+     *            the sixth source Observable
+     * @param o7
+     *            the seventh source Observable
+     * @param o8
+     *            the eighth source Observable
+     * @param o9
+     *            the ninth source Observable
+     * @param combineFunction
+     *            the aggregation function used to combine the
+     *            items emitted by the source Observables
+     * @return an Observable whose emissions are the result of combining the
+     *         emissions of the source Observables with the given aggregation
+     *         function
+     * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable from(T[] items) {
-        return from(Arrays.asList(items));
+    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));
     }
 
     /**
-     * Converts an Array into an Observable.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by two or more
+     * Observables, one after the other.
      * 
    
-     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
-     * the sequence before it completes.
+     * 
      * 
-     * @param items
-     *            the source array
-     * @param scheduler
-     *            the scheduler to emit the items of the array
-     * @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
-     * @see RxJava Wiki: from()
+     * @param observables
+     *            an Observable that emits 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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    public static  Observable from(T[] items, Scheduler scheduler) {
-        return from(Arrays.asList(items), scheduler);
+    public static  Observable concat(Observable> observables) {
+        return create(OperationConcat.concat(observables));
     }
 
     /**
-     * Converts an item into an Observable that emits that item.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by two Observables,
+     * one after the other.
      * 
    
-     * Note: the item is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            the item
-     * @param 
-     *            the type of the item, and the type of the item to be
-     *            emitted by the resulting Observable
-     * @return an Observable that emits the item
-     * @see RxJava Wiki: from()
+     *            an Observable to be concatenated
+     * @param t2
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
     @SuppressWarnings("unchecked")
-    // suppress unchecked because we are using varargs inside the method
-    public static  Observable from(T t1) {
-        return from(Arrays.asList(t1));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by three Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}
+     *            an Observable to be concatenated
+     * @param t3
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by four Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
-     * @param t3
-     *            third item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
-     */
-    @Deprecated
-    @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 that emits those items.
-     * 
    
-     * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by five Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
+     *            an Observable to be concatenated
      * @param t5
-     *            fifth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by six Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
+     *            an Observable to be concatenated
      * @param t5
-     *            fifth item
+     *            an Observable to be concatenated
      * @param t6
-     *            sixth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by secven Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
+     *            an Observable to be concatenated
      * @param t5
-     *            fifth item
+     *            an Observable to be concatenated
      * @param t6
-     *            sixth item
+     *            an Observable to be concatenated
      * @param t7
-     *            seventh item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by eight Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
+     *            an Observable to be concatenated
      * @param t5
-     *            fifth item
+     *            an Observable to be concatenated
      * @param t6
-     *            sixth item
+     *            an Observable to be concatenated
      * @param t7
-     *            seventh item
+     *            an Observable to be concatenated
      * @param t8
-     *            eighth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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));
+    // 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));
     }
 
     /**
-     * Converts a series of items into an Observable that emits those items.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by nine Observables,
+     * one after the other.
      * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
-     * returned, it is not possible to unsubscribe from the sequence before it
-     * completes.
+     * 
      * 
      * @param t1
-     *            first item
+     *            an Observable to be concatenated
      * @param t2
-     *            second item
+     *            an Observable to be concatenated
      * @param t3
-     *            third item
+     *            an Observable to be concatenated
      * @param t4
-     *            fourth item
+     *            an Observable to be concatenated
      * @param t5
-     *            fifth item
+     *            an Observable to be concatenated
      * @param t6
-     *            sixth item
+     *            an Observable to be concatenated
      * @param t7
-     *            seventh item
+     *            an Observable to be concatenated
      * @param t8
-     *            eighth item
+     *            an Observable to be concatenated
      * @param t9
-     *            ninth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     *            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 RxJava Wiki: concat()
+     * @see MSDN: Observable.Concat
      */
-    @Deprecated
     @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 that emits those items.
-     * 
    
-     * 
-     * 
    
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
-     * @param t3
-     *            third item
-     * @param t4
-     *            fourth item
-     * @param t5
-     *            fifth item
-     * @param t6
-     *            sixth item
-     * @param t7
-     *            seventh item
-     * @param t8
-     *            eighth item
-     * @param t9
-     *            ninth item
-     * @param t10
-     *            tenth item
-     * @param 
-     *            the type of items, and the type of items to be emitted by the
-     *            resulting Observable
-     * @return an Observable that emits each item
-     * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
-     */
-    @Deprecated
-    @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));
+    // 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));
     }
 
     /**
-     * Generates an Observable that emits a sequence of Integers within a
-     * specified range.
-     * 
    
-     * 
+     * Creates an Observable that will execute the given function when an {@link Observer} subscribes to it.
      * 
    
-     * 
-     * @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 RxJava Wiki: range()
-     * @see MSDN: Observable.Range
-     */
-    public static Observable range(int start, int count) {
-        return from(Range.createWithCount(start, count));
-    }
-
-    /**
-     * Generates an Observable that emits a sequence of Integers within a
-     * specified range with the specified scheduler.
+     * 
      * 
    
-     * 
-     * 
-     * @param start
-     *            the value of the first Integer in the sequence
-     * @param count
-     *            the number of sequential Integers to generate
-     * @param scheduler
-     *            the scheduler to run the generator loop on
-     * @return an Observable that emits a range of sequential Integers
-     * @see RxJava Wiki: range()
-     * @see MSDN: Observable.Range
-     */
-    public static Observable range(int start, int count, Scheduler scheduler) {
-        return from(Range.createWithCount(start, count), scheduler);
-    }
-
-    /**
-     * Repeats the observable sequence indefinitely.
+     * 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.
      * 
    
-     * 
-     * 
-     * @return an Observable that emits the items emitted by the source
-     *         Observable repeatedly and in sequence
-     * @see RxJava Wiki: repeat()
-     * @see MSDN: Observable.Repeat
-     */
-    public Observable repeat() {
-        return this.repeat(Schedulers.currentThread());
-    }
-
-    /**
-     * Repeats the observable sequence indefinitely, on a particular scheduler.
+     * 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 scheduler
-     *            the scheduler to send the values on.
-     * @return an Observable that emits the items emitted by the source
-     *         Observable repeatedly and in sequence
-     * @see RxJava Wiki: repeat()
-     * @see MSDN: Observable.Repeat
+     * @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 cancel the subscription
+     * @return an Observable that, when an {@link Observer} subscribes to it,
+     *         will execute the given function
+     * @see RxJava Wiki: create()
+     * @see MSDN: Observable.Create
      */
-    public Observable repeat(Scheduler scheduler) {
-        return create(OperationRepeat.repeat(this, scheduler));
+    public static  Observable create(OnSubscribeFunc func) {
+        return new Observable(func);
     }
 
     /**
@@ -1233,812 +1038,869 @@ public static  Observable defer(Func0> o
     }
 
     /**
-     * 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.
+     * Returns an Observable that emits no items to the {@link Observer} and
+     * immediately invokes its {@link Observer#onCompleted onCompleted} 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 emit
      * @param 
-     *            the type of that item
-     * @return an Observable that emits a single item and then completes
-     * @see RxJava Wiki: just()
-     * @deprecated Use {@link #from(T)}
+     *            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
+     * @see RxJava Wiki: empty()
+     * @see MSDN: Observable.Empty
      */
-    @Deprecated
-    public static  Observable just(T value) {
-        return from(Arrays.asList((value)));
+    public static  Observable empty() {
+        return from(new ArrayList());
     }
 
     /**
-     * Returns an Observable that emits a single item and then completes, on a
-     * specified scheduler.
-     * 
    
-     * 
+     * Returns an Observable that emits no items to the {@link Observer} and
+     * immediately invokes its {@link Observer#onCompleted onCompleted} method
+     * with the specified scheduler.
      * 
    
-     * This is a scheduler version of {@link Observable#just(Object)}.
+     * 
      * 
-     * @param value
-     *            the item to emit
-     * @param 
-     *            the type of that item
      * @param scheduler
-     *            the scheduler to emit the single item on
-     * @return an Observable that emits a single item and then completes, on a
+     *            the scheduler to call the {@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 with the
      *         specified scheduler
-     * @see RxJava Wiki: just()
-     * @deprecated Use {@link #from(T)}
+     * @see RxJava Wiki: empty()
+     * @see MSDN: Observable.Empty Method (IScheduler)
      */
-    @Deprecated
-    public static  Observable just(T value, Scheduler scheduler) {
-        return from(Arrays.asList((value)), scheduler);
+    public static  Observable empty(Scheduler scheduler) {
+        return Observable. empty().subscribeOn(scheduler);
     }
 
     /**
-     * Flattens a sequence of Observables emitted by an Observable into one
-     * Observable, without any transformation.
-     * 
    
-     * 
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the Observer subscribes to
+     * it.
      * 
    
-     * 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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @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
+     * @see RxJava Wiki: error()
+     * @see MSDN: Observable.Throw
      */
-    public static  Observable merge(Observable> source) {
-        return create(OperationMerge.merge(source));
+    public static  Observable error(Throwable exception) {
+        return new ThrowObservable(exception);
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
-     * 
    
-     * 
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method with the specified scheduler.
      * 
    
-     * 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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param exception
+     *            the particular error to report
+     * @param scheduler
+     *            the scheduler to call the {@link Observer#onError onError} method
+     * @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 with the specified
+     *         scheduler
+     * @see RxJava Wiki: error()
+     * @see MSDN: Observable.Throw
      */
-    public static  Observable merge(Observable t1, Observable t2) {
-        return merge(from(t1, t2));
+    public static  Observable error(Throwable exception, Scheduler scheduler) {
+        return Observable. error(exception).subscribeOn(scheduler);
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts a {@link Future} into an Observable.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * 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 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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @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
+     * @see RxJava Wiki: from()
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3) {
-        return merge(from(t1, t2, t3));
+    public static  Observable from(Future future) {
+        return create(OperationToObservableFuture.toObservableFuture(future));
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts a {@link Future} into an Observable with timeout.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * 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 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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param future
+     *            the source {@link Future}
+     * @param timeout
+     *            the maximum time to wait before calling get()
+     * @param unit
+     *            the {@link TimeUnit} of the timeout 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}
+     * @see RxJava Wiki: from()
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) {
-        return merge(from(t1, t2, t3, t4));
+    public static  Observable from(Future future, long timeout, TimeUnit unit) {
+        return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * 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.
      * 
    
-     * 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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @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
+     * @see RxJava Wiki: from()
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
-        return merge(from(t1, t2, t3, t4, t5));
+    public static  Observable from(Future future, Scheduler scheduler) {
+        return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts an {@link Iterable} sequence into an Observable.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * Note: the entire iterable sequence is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to
+     * unsubscribe from
+     * the sequence before it completes.
      * 
-     * @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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @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
+     * @see RxJava Wiki: from()
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
-        return merge(from(t1, t2, t3, t4, t5, t6));
+    public static  Observable from(Iterable iterable) {
+        return from(iterable, Schedulers.immediate());
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts an {@link Iterable} sequence into an Observable with the
+     * specified scheduler.
      * 
    
-     * 
+     * 
+     * 
+     * @param iterable
+     *            the source {@link Iterable} sequence
+     * @param scheduler
+     *            the scheduler to emit the items of the iterable
+     * @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 with the specified scheduler
+     * @see RxJava Wiki: from()
+     * @see MSDN: Observable.ToObservable
+     */
+    public static  Observable from(Iterable iterable, Scheduler scheduler) {
+        return create(OperationToObservableIterable.toObservableIterable(iterable, scheduler));
+    }
+
+    /**
+     * Converts an item into an Observable that emits that item.
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * 
+     * 
    
+     * Note: the item is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
      * @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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     *            the item
+     * @param 
+     *            the type of the item, and the type of the item to be
+     *            emitted by the resulting Observable
+     * @return an Observable that emits the item
+     * @see RxJava Wiki: from()
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
-        return merge(from(t1, t2, t3, t4, t5, t6, t7));
+    @SuppressWarnings("unchecked")
+    // suppress unchecked because we are using varargs inside the method
+    public static  Observable from(T t1) {
+        return from(Arrays.asList(t1));
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
      * @param t1
-     *            an Observable to be merged
+     *            first item
      * @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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     *            second item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
-        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens a series of Observables into one Observable, without any
-     * transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they act
-     * like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
      * @param t1
-     *            an Observable to be merged
+     *            first item
      * @param t2
-     *            an Observable to be merged
+     *            second item
      * @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 RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     *            third item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    // 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 merge(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens a sequence of Observables emitted by an Observable into one Observable, without any transformation.
-     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param source
-     *            an Observable that emits Observables
-     * @param maxConcurrent
-     *            the maximum number of Observables being subscribed to concurrently
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables emitted by the {@code source} Observable
-     * @throw IllegalArgumentException if maxConcurrent <= 0
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Observable> source, int maxConcurrent) {
-        return create(OperationMerge.merge(source, maxConcurrent));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param sequences
-     *            the Observable Iterable
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the Iterable
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Iterable> sequences) {
-        return merge(from(sequences));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable Iterable into one Observable, without any transformation.
-     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param sequences
-     *            the Observable Iterable
-     * @param maxConcurrent
-     *            the maximum number of Observables being subscribed to concurrently
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the Iterable
-     * @throw IllegalArgumentException if maxConcurrent <= 0
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Iterable> sequences, int maxConcurrent) {
-        return merge(from(sequences), maxConcurrent);
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable Iterable into one Observable, without any transformation.
-     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param sequences
-     *            the Observable Iterable
-     * @param maxConcurrent
-     *            the maximum number of Observables being subscribed to concurrently
-     * @param scheduler
-     *            the scheduler to traversal the Observable array on
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the Iterable
-     * @throw IllegalArgumentException if maxConcurrent <= 0
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Iterable> sequences, int maxConcurrent, Scheduler scheduler) {
-        return merge(from(sequences, scheduler), maxConcurrent);
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param sequences
-     *            the Observable Iterable
-     * @param scheduler
-     *            the scheduler to traversal the Observable array on
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the Iterable
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Iterable> sequences, Scheduler scheduler) {
-        return merge(from(sequences, scheduler));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable array into one Observable, without any transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
+     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is
+     * returned, it is not possible to unsubscribe from the sequence before it
+     * completes.
      * 
-     * @param sequences
-     *            the Observable array
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the array
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
-     */
-    public static  Observable merge(Observable[] sequences) {
-        return merge(from(sequences));
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param t9
+     *            ninth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     */
+    @Deprecated
+    @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));
     }
 
     /**
-     * Flattens an Observable array into one Observable, without any transformation.
+     * Converts a series of items into an Observable that emits those items.
      * 
    
-     * 
+     * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they
-     * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param sequences
-     *            the Observable array
-     * @param scheduler
-     *            the scheduler to traversal the Observable array on
-     * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the Observables in the array
-     * @see RxJava Wiki: merge()
-     * @see MSDN: Observable.Merge
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param t6
+     *            sixth item
+     * @param t7
+     *            seventh item
+     * @param t8
+     *            eighth item
+     * @param t9
+     *            ninth item
+     * @param t10
+     *            tenth item
+     * @param 
+     *            the type of items, and the type of items to be emitted by the
+     *            resulting Observable
+     * @return an Observable that emits each item
+     * @see RxJava Wiki: from()
+     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
      */
-    public static  Observable merge(Observable[] sequences, Scheduler scheduler) {
-        return merge(from(sequences, scheduler));
+    @Deprecated
+    @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));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by two or more
-     * Observables, one after the other.
+     * Converts an Array into an Observable that emits the items in the Array.
      * 
    
-     * 
+     * 
+     * 
    
+     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
+     * the sequence before it completes.
      * 
-     * @param observables
-     *            an Observable that emits 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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param items
+     *            the source array
+     * @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
+     * @see RxJava Wiki: from()
      */
-    public static  Observable concat(Observable> observables) {
-        return create(OperationConcat.concat(observables));
+    public static  Observable from(T[] items) {
+        return from(Arrays.asList(items));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by two Observables,
-     * one after the other.
+     * Converts an Array into an Observable.
      * 
    
-     * 
+     * 
+     * 
    
+     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
+     * the sequence before it completes.
      * 
-     * @param t1
-     *            an Observable to be concatenated
-     * @param t2
-     *            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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param items
+     *            the source array
+     * @param scheduler
+     *            the scheduler to emit the items of the array
+     * @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
+     * @see RxJava Wiki: from()
      */
-    @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));
+    public static  Observable from(T[] items, Scheduler scheduler) {
+        return from(Arrays.asList(items), scheduler);
     }
 
     /**
-     * Returns an Observable that emits the items emitted by three Observables,
-     * one after the other.
+     * Returns an Observable that emits an item each time interval, containing
+     * a sequential number.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            an Observable to be concatenated
-     * @param t2
-     *            an Observable to be concatenated
-     * @param t3
-     *            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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @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 RxJava Wiki: interval()
+     * @see MSDN: Observable.Interval
      */
-    @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));
+    public static Observable interval(long interval, TimeUnit unit) {
+        return create(OperationInterval.interval(interval, unit));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by four Observables,
-     * one after the other.
+     * Returns an Observable that emits an item each time interval, containing
+     * a sequential number.
      * 
    
-     * 
+     * 
      * 
-     * @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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @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 RxJava Wiki: interval()
+     * @see MSDN: Observable.Interval
      */
-    @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));
+    public static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationInterval.interval(interval, unit, scheduler));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by five Observables,
-     * one after the other.
+     * 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 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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param value
+     *            the item to emit
+     * @param 
+     *            the type of that item
+     * @return an Observable that emits a single item and then completes
+     * @see RxJava Wiki: just()
+     * @deprecated Use {@link #from(T)}
      */
-    @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));
+    @Deprecated
+    public static  Observable just(T value) {
+        return from(Arrays.asList((value)));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by six Observables,
-     * one after the other.
+     * Returns an Observable that emits a single item and then completes, on a
+     * specified scheduler.
      * 
    
-     * 
+     * 
+     * 
    
+     * This is a scheduler version of {@link Observable#just(Object)}.
      * 
-     * @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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param value
+     *            the item to emit
+     * @param 
+     *            the type of that item
+     * @param scheduler
+     *            the scheduler to emit the single item on
+     * @return an Observable that emits a single item and then completes, on a
+     *         specified scheduler
+     * @see RxJava Wiki: just()
+     * @deprecated Use {@link #from(T)}
      */
-    @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));
+    @Deprecated
+    public static  Observable just(T value, Scheduler scheduler) {
+        return from(Arrays.asList((value)), scheduler);
     }
 
     /**
-     * Returns an Observable that emits the items emitted by secven Observables,
-     * one after the other.
+     * Returns an Observable that emits the maximum item emitted by the source
+     * Observable. If there is more than one item with the same maximum value,
+     * it emits the last-emitted of these.
      * 
    
-     * 
+     * 
      * 
-     * @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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param source
+     *            an Observable to scan for the maximum emitted item
+     * @return an Observable that emits this maximum item from the source
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see RxJava Wiki: max()
+     * @see MSDN: Observable.Max
      */
-    @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));
+    public static > Observable max(Observable source) {
+        return OperationMinMax.max(source);
     }
 
     /**
-     * Returns an Observable that emits the items emitted by eight Observables,
-     * one after the other.
+     * Flattens an Observable Iterable 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 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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param sequences
+     *            the Observable Iterable
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Iterable> sequences) {
+        return merge(from(sequences));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by nine Observables,
-     * one after the other.
+     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
      * 
    
-     * 
+     * 
+     * 
    
+     * You can combine the 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 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 RxJava Wiki: concat()
-     * @see MSDN: Observable.Concat
+     * @param sequences
+     *            the Observable Iterable
+     * @param maxConcurrent
+     *            the maximum number of Observables being subscribed to concurrently
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the Iterable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Iterable> sequences, int maxConcurrent) {
+        return merge(from(sequences), maxConcurrent);
     }
 
     /**
-     * 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.
-     * 
    
-     * 
+     * Flattens an Observable Iterable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
      * 
    
-     * 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.
+     * 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
+     * @param sequences
+     *            the Observable Iterable
+     * @param maxConcurrent
+     *            the maximum number of Observables being subscribed to concurrently
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
      * @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 RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge
+     *         the items emitted by the Observables in the Iterable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    public static  Observable mergeDelayError(Observable> source) {
-        return create(OperationMergeDelayError.mergeDelayError(source));
+    public static  Observable merge(Iterable> sequences, int maxConcurrent, Scheduler scheduler) {
+        return merge(from(sequences, scheduler), maxConcurrent);
     }
 
     /**
-     * This behaves like {@link #merge(Observable, 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.
-     * 
    
-     * 
+     * Flattens an Observable Iterable into one Observable, without any transformation.
      * 
    
-     * 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.
+     * You can combine the 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 sequences
+     *            the Observable Iterable
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
      * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the {@code source} Observables
-     * @see RxJava Wiki: mergeDelayError()
-     * @see MSDN: Observable.Merge
+     *         the items emitted by the Observables in the Iterable
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Iterable> sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a sequence of Observables emitted by an Observable into one
+     * Observable, without any transformation.
      * 
    
-     * 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.
+     * You can combine the 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 source
+     *            an Observable that emits Observables
      * @return an Observable that emits items that are the result of flattening
-     *         the items emitted by the {@code source} Observables
-     * @see RxJava Wiki: mergeDelayError()
+     *         the items emitted by the Observables emitted by the {@code source} Observable
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable> source) {
+        return create(OperationMerge.merge(source));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, 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.
+     * Flattens a sequence of Observables emitted by an Observable into one Observable, without any transformation.
+     * The number of concurrent subscriptions to the Observables is limited by maxConcurrent.
      * 
    
-     * 
+     * 
      * 
    
-     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only invoke the {@code onError} method of
-     * its Observers once.
+     * 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
+     * @param maxConcurrent
+     *            the maximum number of Observables being subscribed to concurrently
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables emitted by the {@code source} Observable
+     * @throw IllegalArgumentException if maxConcurrent <= 0
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable> source, int maxConcurrent) {
+        return create(OperationMerge.merge(source, maxConcurrent));
+    }
+
+    /**
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 
+     * 
    
+     * 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 RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable t1, Observable t2) {
+        return merge(from(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 RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
+     */
+    public static  Observable merge(Observable t1, Observable t2, Observable t3) {
+        return merge(from(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
@@ -2050,29 +1912,21 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) {
+        return merge(from(t1, t2, t3, t4));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 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
@@ -2086,29 +1940,21 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
+        return merge(from(t1, t2, t3, t4, t5));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 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
@@ -2124,29 +1970,21 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
+        return merge(from(t1, t2, t3, t4, t5, t6));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 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
@@ -2164,29 +2002,21 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
+        return merge(from(t1, t2, t3, t4, t5, t6, t7));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 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
@@ -2206,29 +2036,21 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
+        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
-     * 
    
-     * 
+     * Flattens a series of Observables into one Observable, without any
+     * transformation.
      * 
    
-     * 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.
+     * 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
@@ -2250,878 +2072,1172 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *            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 RxJava Wiki: mergeDelayError()
+     * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    @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));
+    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) {
+        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
 
     /**
-     * Returns an Observable that never sends any items or notifications to an {@link Observer}.
+     * Flattens an Observable array into one Observable, without any transformation.
      * 
    
-     * 
+     * 
      * 
    
-     * This Observable is useful primarily for testing purposes.
+     * You can combine the items emitted by multiple Observables so that they
+     * act like a single Observable, by using the {@code merge} method.
      * 
-     * @param 
-     *            the type of items (not) emitted by the Observable
-     * @return an Observable that never emits any items or sends any
-     *         notifications to an {@link Observer}
-     * @see RxJava Wiki: never()
+     * @param sequences
+     *            the Observable array
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the array
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    public static  Observable never() {
-        return new NeverObservable();
+    public static  Observable merge(Observable[] sequences) {
+        return merge(from(sequences));
     }
 
     /**
-     * Given an Observable that emits Observables, returns an Observable that
-     * emits the items emitted by the most recently emitted of those
-     * Observables.
+     * Flattens an Observable array 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 sequenceOfSequences
-     *            the source Observable that emits Observables
-     * @return an Observable that emits only the items emitted by the Observable
-     *         most recently emitted by the source Observable
-     * @see RxJava Wiki: switchOnNext()
-     * @deprecated use {@link #switchOnNext}
-     */
-    @Deprecated
-    public static  Observable switchDo(Observable> sequenceOfSequences) {
-        return create(OperationSwitch.switchDo(sequenceOfSequences));
-    }
-
-    /**
-     * Given an Observable that emits Observables, returns an Observable that
-     * emits the items emitted by the most recently emitted of those
-     * Observables.
-     * 
    
-     * 
-     * 
-     * @param sequenceOfSequences
-     *            the source Observable that emits Observables
-     * @return an Observable that emits only the items emitted by the Observable
-     *         most recently emitted by the source Observable
-     * @see RxJava Wiki: switchOnNext()
+     * @param sequences
+     *            the Observable array
+     * @param scheduler
+     *            the scheduler to traversal the Observable array on
+     * @return an Observable that emits items that are the result of flattening
+     *         the items emitted by the Observables in the array
+     * @see RxJava Wiki: merge()
+     * @see MSDN: Observable.Merge
      */
-    public static  Observable switchOnNext(Observable> sequenceOfSequences) {
-        return create(OperationSwitch.switchDo(sequenceOfSequences));
+    public static  Observable merge(Observable[] sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
     }
 
     /**
-     * Given an Observable that emits Observables, returns an Observable that
-     * emits the items emitted by the most recently emitted of those
-     * Observables.
+     * 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 sequenceOfSequences
-     *            the source Observable that emits Observables
-     * @return an Observable that emits only the items emitted by the Observable
-     *         most recently emitted by the source Observable
-     * @see RxJava Wiki: switchOnNext()
-     * @see {@link #switchOnNext(Observable)}
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static  Observable switchLatest(Observable> sequenceOfSequences) {
-        return create(OperationSwitch.switchDo(sequenceOfSequences));
+    public static  Observable mergeDelayError(Observable> source) {
+        return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
     /**
-     * Accepts an Observable and wraps it in another Observable that ensures
-     * that the resulting Observable is chronologically well-behaved.
+     * This behaves like {@link #merge(Observable, 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.
      * 
    
-     * 
+     * 
      * 
    
-     * 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.
+     * 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.
      * 
-     * @return an Observable that is a chronologically well-behaved version of
-     *         the source Observable, and that synchronously notifies its {@link Observer}s
-     * @see RxJava Wiki: synchronize()
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public Observable synchronize() {
-        return create(OperationSynchronize.synchronize(this));
+    @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));
     }
 
     /**
-     * Accepts an Observable and wraps it in another Observable that ensures
-     * that the resulting Observable is chronologically well-behaved. This is
-     * accomplished by acquiring a mutual-exclusion lock for the object provided
-     * as the lock parameter.
+     * This behaves like {@link #merge(Observable, Observable, 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.
      * 
    
-     * 
+     * 
      * 
    
-     * 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.
+     * 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 lock
-     *            the lock object to synchronize each observer call on
-     * @return an Observable that is a chronologically well-behaved version of
-     *         the source Observable, and that synchronously notifies its {@link Observer}s
-     * @see RxJava Wiki: synchronize()
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public Observable synchronize(Object lock) {
-        return create(OperationSynchronize.synchronize(this, lock));
+    @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));
     }
 
     /**
-     * @deprecated use {@link #synchronize()} or {@link #synchronize(Object)}
+     * This behaves like {@link #merge(Observable, Observable, Observable, 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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    @Deprecated
-    public static  Observable synchronize(Observable source) {
-        return create(OperationSynchronize.synchronize(source));
+    @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));
     }
 
     /**
-     * Returns an Observable that emits an item each time interval, containing
-     * a sequential number.
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, 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 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 RxJava Wiki: interval()
-     * @see MSDN: Observable.Interval
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static Observable interval(long interval, TimeUnit unit) {
-        return create(OperationInterval.interval(interval, unit));
+    @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));
     }
 
     /**
-     * Returns an Observable that emits an item each time interval, containing
-     * a sequential number.
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, 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 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 RxJava Wiki: interval()
-     * @see MSDN: Observable.Interval
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationInterval.interval(interval, unit, scheduler));
+    @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));
     }
 
     /**
-     * Returns an Observable that emits one item after a given delay, and then
-     * completes.
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, 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 delay
-     *            the initial delay before emitting a single 0L
-     * @param unit
-     *            time units to use for the interval size
-     * @see RxJava wiki: timer()
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static Observable timer(long delay, TimeUnit unit) {
-        return timer(delay, unit, Schedulers.threadPoolForComputation());
+    @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));
     }
 
     /**
-     * Returns an Observable that emits one item after a given delay, and then
-     * completes.
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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 delay
-     *            the initial delay before emitting a single 0L
-     * @param unit
-     *            time units to use for the interval size
-     * @param scheduler
-     *            the scheduler to use for scheduling the item
-     * @see RxJava wiki: timer()
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTimer.TimerOnce(delay, unit, scheduler));
+    @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));
     }
 
     /**
-     * Return an Observable which emits a 0L after the {@code initialDelay} and
-     * ever increasing numbers after each {@code period}.
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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 initialDelay
-     *            the initial delay time to wait before emitting the
-     *            first value of 0L
-     * @param period
-     *            the time period after emitting the subsequent numbers
-     * @param unit
-     *            the time unit for both initialDelay and
-     *            period
-     * @return an Observable which emits a 0L after the {@code initialDelay} and
-     *         ever increasing numbers after each {@code period}
-     * @see RxJava Wiki: timer()
-     * @see MSDN: Observable.Timer
+     * @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 RxJava Wiki: mergeDelayError()
+     * @see MSDN: Observable.Merge
      */
-    public static Observable timer(long initialDelay, long period, TimeUnit unit) {
-        return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation());
+    @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));
     }
 
     /**
-     * Return an Observable which emits a 0L after the {@code initialDelay} and
-     * ever increasing numbers after each {@code period} while running on the
-     * given {@code scheduler}.
+     * Returns an Observable that emits the minimum item emitted by the source
+     * Observable. If there is more than one such item, it returns the
+     * last-emitted one.
      * 
    
-     * 
+     * 
      * 
-     * @param initialDelay
-     *            the initial delay time to wait before emitting the
-     *            first value of 0L
-     * @param period
-     *            the time period after emitting the subsequent numbers
-     * @param unit
-     *            the time unit for both initialDelay and
-     *            period
-     * @param scheduler
-     *            the scheduler on which the waiting happens and value
-     *            emissions run
-     * @return an Observable that emits a 0L after the {@code initialDelay} and
-     *         ever increasing numbers after each {@code period} while running
-     *         on the given {@code scheduler}
-     * @see RxJava Wiki: timer()
-     * @see MSDN: Observable.Timer
+     * @param source
+     *            an Observable to determine the minimum item of
+     * @return an Observable that emits the minimum item emitted by the source
+     *         Observable
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see MSDN: Observable.Min
      */
-    public static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler));
+    public static > Observable min(Observable source) {
+        return OperationMinMax.min(source);
     }
 
     /**
-     * Create an Observable which delays the events via another Observable on a per item-basis.
+     * Returns an Observable that never sends any items or notifications to an {@link Observer}.
      * 
    
-     * Note: onError event is immediately propagated.
+     * 
+     * 
    
+     * This Observable is useful primarily for testing purposes.
      * 
-     * @param 
-     *            the item delay value type (ignored)
-     * @param itemDelay
-     *            function that returns an Observable for each source item which is
-     *            then used for delaying that particular item until the Observable
-     *            fires its first onNext event.
-     * @return an Observable which delays the events via another Observable on a per item-basis.
+     * @param 
+     *            the type of items (not) emitted by the Observable
+     * @return an Observable that never emits any items or sends any
+     *         notifications to an {@link Observer}
+     * @see RxJava Wiki: never()
      */
-    public  Observable delay(Func1> itemDelay) {
-        return create(OperationDelay.delay(this, itemDelay));
+    public static  Observable never() {
+        return new NeverObservable();
     }
 
     /**
-     * Create an Observable which delays the subscription and events via another Observables on a per item-basis.
+     * Merges an Observable<Observable<T>> to
+     * Observable<Observable<T>> with the number of
+     * inner Observables defined by parallelObservables.
      * 
    
-     * Note: onError event is immediately propagated.
+     * For example, if the original
+     * Observable<Observable<T>> has 100 Observables to
+     * be emitted and parallelObservables is 8, the 100 will be
+     * grouped onto 8 output Observables.
+     * 
    
+     * This is a mechanism for efficiently processing n number of
+     * Observables on a smaller m number of resources (typically CPU
+     * cores).
+     * 
    
+     * 
      * 
-     * @param 
-     *            the subscription delay value type (ignored)
-     * @param 
-     *            the item delay value type (ignored)
-     * @param subscriptionDelay
-     *            function that returns an Observable which will trigger
-     *            the subscription to the source observable once it fires an
-     *            onNext event.
-     * @param itemDelay
-     *            function that returns an Observable for each source item which is
-     *            then used for delaying that particular item until the Observable
-     *            fires its first onNext event.
-     * @return an Observable which delays the events via another Observable on a per item-basis.
+     * @param parallelObservables
+     *            the number of Observables to merge into
+     * @return an Observable of Observables constrained in number by
+     *         parallelObservables
+     * @see RxJava Wiki: parallelMerge()
      */
-    public  Observable delay(
-            Func0> subscriptionDelay,
-            Func1> itemDelay) {
-        return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
+    public static  Observable> parallelMerge(Observable> source, int parallelObservables) {
+        return OperationParallelMerge.parallelMerge(source, parallelObservables);
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source
-     * Observable shifted forward in time by a specified delay. Error
-     * notifications from the source Observable are not delayed.
+     * Merges an Observable<Observable<T>> to
+     * Observable<Observable<T>> with the number of
+     * inner Observables defined by parallelObservables and runs
+     * each Observable on the defined Scheduler.
      * 
    
-     * 
-     * 
-     * @param delay
-     *            the delay to shift the source by
-     * @param unit
-     *            the {@link TimeUnit} in which period is defined
-     * @return the source Observable, but shifted by the specified delay
-     * @see RxJava Wiki: delay()
-     * @see MSDN: Observable.Delay
-     */
-    public Observable delay(long delay, TimeUnit unit) {
-        return OperationDelay.delay(this, delay, unit, Schedulers.threadPoolForComputation());
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by the source
-     * Observable shifted forward in time by a specified delay. Error
-     * notifications from the source Observable are not delayed.
+     * For example, if the original
+     * Observable<Observable<T>> has 100 Observables to
+     * be emitted and parallelObservables is 8, the 100 will be
+     * grouped onto 8 output Observables.
      * 
    
-     * 
+     * This is a mechanism for efficiently processing n number of
+     * Observables on a smaller m number of resources (typically CPU
+     * cores).
+     * 
    
+     * 
      * 
-     * @param delay
-     *            the delay to shift the source by
-     * @param unit
-     *            the {@link TimeUnit} in which period is defined
+     * @param parallelObservables
+     *            the number of Observables to merge into
      * @param scheduler
-     *            the {@link Scheduler} to use for delaying
-     * @return the source Observable, but shifted by the specified delay
-     * @see RxJava Wiki: delay()
-     * @see MSDN: Observable.Delay
+     *            the Scheduler to run each Observable on
+     * @return an Observable of Observables constrained in number by
+     *         parallelObservables
+     * @see RxJava Wiki: parallelMerge()
      */
-    public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
-        return OperationDelay.delay(this, delay, unit, scheduler);
+    public static  Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) {
+        return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
     }
 
     /**
-     * Return an Observable that delays the subscription to the source
-     * Observable by a given amount of time.
+     * Generates an Observable that emits a sequence of Integers within a
+     * specified range.
+     * 
    
+     * 
      * 
    
-     * 
      * 
-     * @param delay
-     *            the time to delay the subscription
-     * @param unit
-     *            the time unit
-     * @return an Observable that delays the subscription to the source
-     *         Observable by the given amount
+     * @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 RxJava Wiki: range()
+     * @see MSDN: Observable.Range
      */
-    public Observable delaySubscription(long delay, TimeUnit unit) {
-        return delaySubscription(delay, unit, Schedulers.threadPoolForComputation());
+    public static Observable range(int start, int count) {
+        return from(Range.createWithCount(start, count));
     }
 
     /**
-     * Return an Observable that delays the subscription to the source
-     * Observable by a given amount of time, both waiting and subscribing on
-     * a given Scheduler.
+     * Generates an Observable that emits a sequence of Integers within a
+     * specified range with the specified scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @param delay
-     *            the time to delay the subscription
-     * @param unit
-     *            the time unit
+     * @param start
+     *            the value of the first Integer in the sequence
+     * @param count
+     *            the number of sequential Integers to generate
      * @param scheduler
-     *            the scheduler on which the waiting and subscription will
-     *            happen
-     * @return an Observable that delays the subscription to the source
-     *         Observable by a given amount, waiting and subscribing on the
-     *         given Scheduler
+     *            the scheduler to run the generator loop on
+     * @return an Observable that emits a range of sequential Integers
+     * @see RxJava Wiki: range()
+     * @see MSDN: Observable.Range
      */
-    public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationDelay.delaySubscription(this, delay, unit, scheduler));
+    public static Observable range(int start, int count, Scheduler scheduler) {
+        return from(Range.createWithCount(start, count), scheduler);
     }
 
     /**
-     * Drops items emitted by an Observable that are followed by newer items
-     * before a timeout value expires. The timer resets on each emission.
-     * 
    
-     * Note: If events keep firing faster than the timeout then no items will be
-     * emitted by the resulting Observable.
-     * 
    
-     * 
-     * 
    
-     * Information on debounce vs throttle:
+     * Returns an Observable that emits a Boolean value that indicates whether
+     * two sequences are equal by comparing the elements emitted by each
+     * Observable pairwise.
      * 
    
-     * 
    
+     * 
      * 
-     * @param timeout
-     *            the time each item has to be "the most recent" of those
-     *            emitted by the source {@link Observable} to ensure that
-     *            it's not dropped
-     * @param unit
-     *            the {@link TimeUnit} for the timeout
-     * @return an {@link Observable} that filters out items that are too quickly
-     *         followed by newer items
-     * @see RxJava Wiki: debounce()
-     * @see #throttleWithTimeout(long, TimeUnit)
+     * @param first
+     *            the first Observable to compare
+     * @param second
+     *            the second Observable to compare
+     * @param 
+     *            the type of items emitted by each Observable
+     * @return an Observable that emits a Boolean value that indicates whether
+     *         two sequences are equal by comparing the elements pairwise
+     * @see RxJava Wiki: sequenceEqual()
      */
-    public Observable debounce(long timeout, TimeUnit unit) {
-        return create(OperationDebounce.debounce(this, timeout, unit));
+    public static  Observable sequenceEqual(Observable first, Observable second) {
+        return sequenceEqual(first, second, new Func2() {
+            @Override
+            public Boolean call(T first, T second) {
+                if (first == null) {
+                    return second == null;
+                }
+                return first.equals(second);
+            }
+        });
     }
 
     /**
-     * Create an Observable that ignores elements from this observable
-     * sequence which are followed by another value within a computed
-     * debounce duration.
+     * Returns an Observable that emits a Boolean value that indicates whether
+     * two sequences are equal by comparing the elements emitted by each
+     * Observable pairwise based on the results of a specified equality
+     * function.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the debounce value type (ignored)
-     * @param debounceSelector
-     *            function to retrieve a sequence indicating the throttle duration for each given element.
-     * @return an Observable that ignores elements from this observable
-     *         sequence which are followed by another value within a computed
-     *         debounce duration
+     * @param first
+     *            the first 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 a Boolean value that indicates whether
+     *         two sequences are equal by comparing the elements pairwise
+     * @see RxJava Wiki: sequenceEqual()
      */
-    public  Observable debounce(Func1> debounceSelector) {
-        return create(OperationDebounce.debounceSelector(this, debounceSelector));
+    public static  Observable sequenceEqual(Observable first, Observable second, Func2 equality) {
+        return OperationSequenceEqual.sequenceEqual(first, second, equality);
+    }
+
+    @Deprecated
+    public static Observable sum(Observable source) {
+        return OperationSum.sum(source);
     }
 
     /**
-     * Drops items emitted by an Observable that are followed by newer items
-     * before a timeout value expires. The timer resets on each emission.
-     * 
    
-     * Note: If events keep firing faster than the timeout then no items will be
-     * emitted by the resulting Observable.
-     * 
    
-     * 
-     * 
    
-     * Information on debounce vs throttle:
+     * Returns an Observable that emits the sum of all the Doubles emitted by
+     * the source Observable.
      * 
    
-     * 
    
+     * 
      * 
-     * @param timeout
-     *            the time each item has to be "the most recent" of those
-     *            emitted by the source {@link Observable} to ensure that
-     *            it's not dropped
-     * @param unit
-     *            the unit of time for the specified timeout
-     * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the
-     *            timers that handle the timeout for each event
-     * @return an {@link Observable} that filters out items that are too quickly
-     *         followed by newer items
-     * @see RxJava Wiki: debounce()
-     * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits the sum of all the Doubles emitted by
+     *         the source Observable as its single item
+     * @see RxJava Wiki: sumDouble()
+     * @see MSDN: Observable.Sum
      */
-    public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
+    public static Observable sumDouble(Observable source) {
+        return OperationSum.sumDoubles(source);
     }
 
     /**
-     * Drops items emitted by an Observable that are followed by newer items
-     * before a timeout value expires. The timer resets on each emission.
-     * 
    
-     * Note: If events keep firing faster than the timeout then no items will be
-     * emitted by the resulting Observable.
-     * 
    
-     * 
-     * 
    
-     * Information on debounce vs throttle:
+     * Returns an Observable that emits the sum of all the Floats emitted by the
+     * source Observable.
      * 
    
-     * 
    
+     * 
      * 
-     * @param timeout
-     *            the time each item has to be "the most recent" of those
-     *            emitted by the source {@link Observable} to ensure that
-     *            it's not dropped
-     * @param unit
-     *            the {@link TimeUnit} for the timeout
-     * @return an {@link Observable} that filters out items that are too quickly
-     *         followed by newer items
-     * @see RxJava Wiki: throttleWithTimeout()
-     * @see #debounce(long, TimeUnit)
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits the sum of all the Floats emitted by the
+     *         source Observable as its single item
+     * @see RxJava Wiki: sumFloat()
+     * @see MSDN: Observable.Sum
      */
-    public Observable throttleWithTimeout(long timeout, TimeUnit unit) {
-        return create(OperationDebounce.debounce(this, timeout, unit));
+    public static Observable sumFloat(Observable source) {
+        return OperationSum.sumFloats(source);
     }
 
     /**
-     * Drops items emitted by an Observable that are followed by newer items
-     * before a timeout value expires. The timer resets on each emission.
-     * 
    
-     * Note: If events keep firing faster than the timeout then no items will be
-     * emitted by the resulting Observable.
-     * 
    
-     * 
-     * 
    
-     * Information on debounce vs throttle:
+     * Returns an Observable that emits the sum of all the Integers emitted by
+     * the source Observable.
      * 
    
-     * 
    
+     * 
      * 
-     * @param timeout
-     *            the time each item has to be "the most recent" emitted by
-     *            the {@link Observable} to ensure that it's not dropped
-     * @param unit
-     *            the {@link TimeUnit} for the timeout
-     * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the
-     *            timers that handle the timeout for each item
-     * @return an {@link Observable} that filters out items that are too quickly
-     *         followed by newer items
-     * @see RxJava Wiki: throttleWithTimeout()
-     * @see #debounce(long, TimeUnit, Scheduler)
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits the sum of all the Integers emitted by
+     *         the source Observable as its single item
+     * @see RxJava Wiki: sumInteger()
+     * @see MSDN: Observable.Sum
      */
-    public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
+    public static Observable sumInteger(Observable source) {
+        return OperationSum.sum(source);
     }
 
     /**
-     * Throttles by skipping items emitted by the source Observable until
-     * windowDuration passes and then emitting the next item
-     * emitted by the source Observable.
-     * 
    
-     * This differs from {@link #throttleLast} in that this only tracks passage
-     * of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * Returns an Observable that emits the sum of all the Longs emitted by the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param windowDuration
-     *            time to wait before emitting another item after
-     *            emitting the last item
-     * @param unit
-     *            the unit of time for the specified timeout
-     * @return an Observable that performs the throttle operation
-     * @see RxJava Wiki: throttleFirst()
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits the sum of all the Longs emitted by the
+     *         source Observable as its single item
+     * @see RxJava Wiki: sumLong()
+     * @see MSDN: Observable.Sum
      */
-    public Observable throttleFirst(long windowDuration, TimeUnit unit) {
-        return create(OperationThrottleFirst.throttleFirst(this, windowDuration, unit));
+    public static Observable sumLong(Observable source) {
+        return OperationSum.sumLongs(source);
     }
 
     /**
-     * Throttles by skipping items emitted by the source Observable until
-     * skipDuration passes and then emitting the next item emitted
-     * by the source Observable.
-     * 
    
-     * This differs from {@link #throttleLast} in that this only tracks passage
-     * of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * Given an Observable that emits Observables, returns an Observable that
+     * emits the items emitted by the most recently emitted of those
+     * Observables.
      * 
    
-     * 
+     * 
      * 
-     * @param skipDuration
-     *            time to wait before emitting another item after
-     *            emitting the last item
-     * @param unit
-     *            the unit of time for the specified timeout
-     * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the
-     *            timers that handle timeout for each event
-     * @return an Observable that performs the throttle operation
-     * @see RxJava Wiki: throttleFirst()
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
+     * @return an Observable that emits only the items emitted by the Observable
+     *         most recently emitted by the source Observable
+     * @see RxJava Wiki: switchOnNext()
+     * @deprecated use {@link #switchOnNext}
      */
-    public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationThrottleFirst.throttleFirst(this, skipDuration, unit, scheduler));
+    @Deprecated
+    public static  Observable switchDo(Observable> sequenceOfSequences) {
+        return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
     /**
-     * Throttles by emitting the last item from the source Observable that falls
-     * in each interval defined by intervalDuration.
-     * 
    
-     * This differs from {@link #throttleFirst} in that this ticks along at a
-     * scheduled interval whereas {@link #throttleFirst} does not tick, it just
-     * tracks passage of time.
+     * Given an Observable that emits Observables, returns an Observable that
+     * emits the items emitted by the most recently emitted of those
+     * Observables.
      * 
    
-     * 
+     * 
      * 
-     * @param intervalDuration
-     *            duration of windows within which the last item
-     *            emitted by the source Observable will be emitted
-     * @param unit
-     *            the unit of time for the specified interval
-     * @return an Observable that performs the throttle operation
-     * @see RxJava Wiki: throttleLast()
-     * @see #sample(long, TimeUnit)
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
+     * @return an Observable that emits only the items emitted by the Observable
+     *         most recently emitted by the source Observable
+     * @see RxJava Wiki: switchOnNext()
+     * @see {@link #switchOnNext(Observable)}
      */
-    public Observable throttleLast(long intervalDuration, TimeUnit unit) {
-        return sample(intervalDuration, unit);
+    public static  Observable switchLatest(Observable> sequenceOfSequences) {
+        return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
     /**
-     * Throttles by emitting the last item in each interval defined by
-     * intervalDuration.
-     * 
    
-     * This differs from {@link #throttleFirst} in that this ticks along at a
-     * scheduled interval whereas {@link #throttleFirst} does not tick, it just
-     * tracks passage of time.
+     * Given an Observable that emits Observables, returns an Observable that
+     * emits the items emitted by the most recently emitted of those
+     * Observables.
      * 
    
-     * 
+     * 
      * 
-     * @param intervalDuration
-     *            duration of windows within which the last item
-     *            emitted by the source Observable will be emitted
-     * @param unit
-     *            the unit of time for the specified interval
-     * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the
-     *            timers that handle timeout for each event
-     * @return an Observable that performs the throttle operation
-     * @see RxJava Wiki: throttleLast()
-     * @see #sample(long, TimeUnit, Scheduler)
+     * @param sequenceOfSequences
+     *            the source Observable that emits Observables
+     * @return an Observable that emits only the items emitted by the Observable
+     *         most recently emitted by the source Observable
+     * @see RxJava Wiki: switchOnNext()
      */
-    public Observable throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
-        return sample(intervalDuration, unit, scheduler);
+    public static  Observable switchOnNext(Observable> sequenceOfSequences) {
+        return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
     /**
-     * Wraps each item emitted by a source Observable in a {@link Timestamped} object.
+     * @deprecated use {@link #synchronize()} or {@link #synchronize(Object)}
+     */
+    @Deprecated
+    public static  Observable synchronize(Observable source) {
+        return create(OperationSynchronize.synchronize(source));
+    }
+
+    /**
+     * Return an Observable which emits a 0L after the {@code initialDelay} and
+     * ever increasing numbers after each {@code period}.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits timestamped items from the source
-     *         Observable
-     * @see RxJava Wiki: timestamp()
-     * @see MSDN: Observable.Timestamp
+     * @param initialDelay
+     *            the initial delay time to wait before emitting the
+     *            first value of 0L
+     * @param period
+     *            the time period after emitting the subsequent numbers
+     * @param unit
+     *            the time unit for both initialDelay and
+     *            period
+     * @return an Observable which emits a 0L after the {@code initialDelay} and
+     *         ever increasing numbers after each {@code period}
+     * @see RxJava Wiki: timer()
+     * @see MSDN: Observable.Timer
      */
-    public Observable> timestamp() {
-        return create(OperationTimestamp.timestamp(this));
+    public static Observable timer(long initialDelay, long period, TimeUnit unit) {
+        return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Wraps each item emitted by a source Observable in a {@link Timestamped} object with timestamps provided by the given Scheduler.
+     * Return an Observable which emits a 0L after the {@code initialDelay} and
+     * ever increasing numbers after each {@code period} while running on the
+     * given {@code scheduler}.
      * 
    
-     * 
+     * 
      * 
+     * @param initialDelay
+     *            the initial delay time to wait before emitting the
+     *            first value of 0L
+     * @param period
+     *            the time period after emitting the subsequent numbers
+     * @param unit
+     *            the time unit for both initialDelay and
+     *            period
      * @param scheduler
-     *            the {@link Scheduler} to use as a time source.
-     * @return an Observable that emits timestamped items from the source
-     *         Observable with timestamps provided by the given Scheduler
-     * @see RxJava Wiki: timestamp()
-     * @see MSDN: Observable.Timestamp
+     *            the scheduler on which the waiting happens and value
+     *            emissions run
+     * @return an Observable that emits a 0L after the {@code initialDelay} and
+     *         ever increasing numbers after each {@code period} while running
+     *         on the given {@code scheduler}
+     * @see RxJava Wiki: timer()
+     * @see MSDN: Observable.Timer
      */
-    public Observable> timestamp(Scheduler scheduler) {
-        return create(OperationTimestamp.timestamp(this, scheduler));
+    public static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler));
     }
 
     /**
-     * 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.
+     * Returns an Observable that emits one item after a given delay, and then
+     * completes.
      * 
    
-     * 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
-     * @see RxJava Wiki: from()
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for the interval size
+     * @see RxJava wiki: timer()
      */
-    public static  Observable from(Future future) {
-        return create(OperationToObservableFuture.toObservableFuture(future));
+    public static Observable timer(long delay, TimeUnit unit) {
+        return timer(delay, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * 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.
+     * Returns an Observable that emits one item after a given delay, and then
+     * completes.
      * 
    
+     * 
      * 
-     * @param future
-     *            the source {@link Future}
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for the interval size
      * @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
-     * @see RxJava Wiki: from()
+     *            the scheduler to use for scheduling the item
+     * @see RxJava wiki: timer()
      */
-    public static  Observable from(Future future, Scheduler scheduler) {
-        return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
+    public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationTimer.TimerOnce(delay, unit, 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.
+     * Constructs an Observable that creates a dependent resource object.
      * 
    
-     * 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 timeout 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}
-     * @see RxJava Wiki: from()
+     * @param resourceFactory
+     *            the factory function to obtain a resource object
+     *            that depends on the Observable
+     * @param observableFactory
+     *            the factory function to obtain an Observable
+     * @return the Observable whose lifetime controls the lifetime of the
+     *         dependent resource object
+     * @see RxJava Wiki: using()
+     * @see MSDN: Observable.Using
      */
-    public static  Observable from(Future future, long timeout, TimeUnit unit) {
-        return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
+    public static  Observable using(Func0 resourceFactory, Func1> observableFactory) {
+        return create(OperationUsing.using(resourceFactory, observableFactory));
     }
 
     /**
-     * Returns an Observable that emits a Boolean value that indicates whether
-     * two sequences are equal by comparing the elements emitted by each
-     * Observable pairwise.
+     * Joins together the results from several patterns.
      * 
    
-     * 
+     * 
      * 
-     * @param first
-     *            the first Observable to compare
-     * @param second
-     *            the second Observable to compare
-     * @param 
-     *            the type of items emitted by each Observable
-     * @return an Observable that emits a Boolean value that indicates whether
-     *         two sequences are equal by comparing the elements pairwise
-     * @see RxJava Wiki: sequenceEqual()
+     * @param plans
+     *            a series of plans created by use of the {@link #then} operator on patterns
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @throws NullPointerException
+     *             if plans is null
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
      */
-    public static  Observable sequenceEqual(Observable first, Observable second) {
-        return sequenceEqual(first, second, new Func2() {
-            @Override
-            public Boolean call(T first, T second) {
-                if (first == null) {
-                    return second == null;
-                }
-                return first.equals(second);
-            }
-        });
+    public static  Observable when(Iterable> plans) {
+        if (plans == null) {
+            throw new NullPointerException("plans");
+        }
+        return create(OperationJoinPatterns.when(plans));
     }
 
     /**
-     * Returns an Observable that emits a Boolean value that indicates whether
-     * two sequences are equal by comparing the elements emitted by each
-     * Observable pairwise based on the results of a specified equality
-     * function.
+     * Joins together the results from several patterns.
      * 
    
-     * 
+     * 
      * 
-     * @param first
-     *            the first 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 a Boolean value that indicates whether
-     *         two sequences are equal by comparing the elements pairwise
-     * @see RxJava Wiki: sequenceEqual()
+     * @param plans
+     *            a series of plans created by use of the {@link #then} operator on patterns
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @throws NullPointerException
+     *             if plans is null
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
      */
-    public static  Observable sequenceEqual(Observable first, Observable second, Func2 equality) {
-        return OperationSequenceEqual.sequenceEqual(first, second, equality);
+    public static  Observable when(Plan0... plans) {
+        return create(OperationJoinPatterns.when(plans));
     }
 
     /**
-     * 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 o1} and the first item emitted by {@code o2}; the second item emitted by the new Observable will be the
-     * result of the function applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; and so forth.
+     * Joins the results from a pattern.
      * 
    
-     * 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
-     *            the first 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
-     * @see RxJava Wiki: zip()
+     * @param p1
+     *            the plan to join
+     * @return an Observable that emits the results from matching a pattern
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
      */
-    public static  Observable zip(Observable o1, Observable o2, Func2 zipFunction) {
-        return create(OperationZip.zip(o1, o2, zipFunction));
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1) {
+        return create(OperationJoinPatterns.when(p1));
     }
 
     /**
-     * Return an Observable that pairs up values from this Observable and the other
-     * Observable and applies a function.
+     * Joins together the results from several patterns.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the other value type
-     * @param 
-     *            the result type
-     * @param other
-     *            the other Observable sequence
-     * @param zipFunction
-     *            the function that combines the pairs of items from both
-     *            observables and returns a new value
-     * @return an Observable that pairs up values from this Observable and the other
-     *         Observable and applies a function.
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
      */
-    public  Observable zip(Observable other, Func2 zipFunction) {
-        return zip(this, other, zipFunction);
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2) {
+        return create(OperationJoinPatterns.when(p1, p2));
     }
 
     /**
-     * Return an Observable that pairs up values from this Observable and an
-     * Iterable sequence and applies a function.
+     * Joins together the results from several patterns.
      * 
    
-     * Note that the other Iterable is evaluated as items appear from this
-     * Observable and is not pre-consumed, allowing zipping infinite streams
-     * on either side.
+     * 
      * 
-     * @param 
-     *            the other value type
-     * @param 
-     *            the result type
-     * @param other
-     *            the other Iterable sequence
-     * @param zipFunction
-     *            the function that combines the pairs of items of
-     *            this Observable and the Iterable
-     * @return an Observable that pairs up values from this Observable and an
-     *         Iterable sequence and applies a function.
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
      */
-    public  Observable zip(Iterable other, Func2 zipFunction) {
-        return create(OperationZip.zipIterable(this, other, zipFunction));
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
+        return create(OperationJoinPatterns.when(p1, p2, p3));
     }
 
     /**
-     * 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.
+     * Joins together the results from several patterns.
      * 
    
-     * 
-     * 
     {@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 o1}, the first item emitted by {@code o2}, and the first item emitted by {@code o3}; the second item
-     * emitted by the new Observable will be the result of the function applied
-     * to the second item emitted by {@code o1}, the second item emitted by {@code o2}, and the second item emitted by {@code o3}; and so forth.
+     * 
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4));
+    }
+
+    /**
+     * Joins together the results from several patterns.
      * 
    
-     * 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
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5));
+    }
+
+    /**
+     * Joins together the results from several patterns.
+     * 
    
+     * 
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6));
+    }
+
+    /**
+     * Joins together the results from several patterns.
+     * 
    
+     * 
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7));
+    }
+
+    /**
+     * Joins together the results from several patterns.
+     * 
    
+     * 
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
+     * @param p8
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8));
+    }
+
+    /**
+     * Joins together the results from several patterns.
+     * 
    
+     * 
+     * 
+     * @param p1
+     *            a plan
+     * @param p2
+     *            a plan
+     * @param p3
+     *            a plan
+     * @param p4
+     *            a plan
+     * @param p5
+     *            a plan
+     * @param p6
+     *            a plan
+     * @param p7
+     *            a plan
+     * @param p8
+     *            a plan
+     * @param p9
+     *            a plan
+     * @return an Observable that emits the results from matching several
+     *         patterns
+     * @see RxJava Wiki: when()
+     * @see MSDN: Observable.When
+     */
+    @SuppressWarnings("unchecked")
+    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8, Plan0 p9) {
+        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your
+     * choosing applied to combinations items emitted, in sequence, by a
+     * collection of 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 source Observables; 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
+     * @see RxJava Wiki: zip()
+     */
+    public static  Observable zip(Iterable> ws, FuncN zipFunction) {
+        return create(OperationZip.zip(ws, zipFunction));
+    }
+
+    /**
+     * 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 source Observables; 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
+     * @see RxJava Wiki: zip()
+     */
+    public static  Observable zip(Observable> ws, final FuncN zipFunction) {
+        return ws.toList().mergeMap(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 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 o1} and the first item emitted by {@code o2}; the second item emitted by the new Observable will be the
+     * result of the function applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; 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
+     *            the first 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
+     * @see RxJava Wiki: zip()
+     */
+    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 o1}, the first item emitted by {@code o2}, and the first item emitted by {@code o3}; the second item
+     * emitted by the new Observable will be the result of the function applied
+     * to the second item emitted by {@code o1}, the second item emitted by {@code o2}, and the second item emitted by {@code o3}; 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
      *            the first source Observable
      * @param o2
      *            a second source Observable
@@ -3385,293 +3501,154 @@ public static  Observable zip(Observab
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Synonymous with reduce().
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @see RxJava Wiki: reduce()
+     * @see #reduce(Func2)
+     * @deprecated use #reduce(Func2)
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction));
+    @Deprecated
+    public Observable aggregate(Func2 accumulator) {
+        return reduce(accumulator);
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Synonymous with reduce().
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @see RxJava Wiki: reduce()
+     * @see #reduce(Object, Func2)
+     * @deprecated use #reduce(Object, Func2)
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction));
+    @Deprecated
+    public  Observable aggregate(R initialValue, Func2 accumulator) {
+        return reduce(initialValue, accumulator);
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Returns an Observable that emits a Boolean that indicates whether all of
+     * the items emitted by the source Observable satisfy a condition.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @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
+     * @see RxJava Wiki: all()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4,
-            Func4 combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction));
+    public Observable all(Func1 predicate) {
+        return create(OperationAll.all(this, predicate));
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Creates a pattern that matches when both Observables emit an item.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param o5
-     *            the fifth source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @param second
+     *            Observable to match with the source Observable
+     * @return Pattern object that matches when both Observables emit an item
+     * @throws NullPointerException
+     *             if right is null
+     * @see RxJava Wiki: and()
+     * @see MSDN: Observable.And
      */
-    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));
+    public  Pattern2 and(Observable right) {
+        return OperationJoinPatterns.and(this, right);
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
-     * 
    
-     * 
+     * Hides the identity of this observable.
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param o5
-     *            the fifth source Observable
-     * @param o6
-     *            the sixth source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @return an Observable hiding the identity of this Observable.
      */
-    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));
+    public Observable asObservable() {
+        return create(new OperationAsObservable(this));
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into doubles by using a function you provide and then emits
+     * the double average of the complete sequence of transformed values.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param o5
-     *            the fifth source Observable
-     * @param o6
-     *            the sixth source Observable
-     * @param o7
-     *            the seventh source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a double
+     * @return an Observable that emits the double average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into doubles by the specified function
+     * @see RxJava Wiki: averageDouble()
+     * @see MSDN: Observable.Average
      */
-    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));
+    public Observable averageDouble(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageDoubleExtractor(this, valueExtractor));
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into floats by using a function you provide and then emits
+     * the float average of the complete sequence of transformed values.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param o5
-     *            the fifth source Observable
-     * @param o6
-     *            the sixth source Observable
-     * @param o7
-     *            the seventh source Observable
-     * @param o8
-     *            the eighth source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a float
+     * @return an Observable that emits the float average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into floats by the specified function
+     * @see RxJava Wiki: averageFloat()
+     * @see MSDN: Observable.Average
      */
-    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));
+    public Observable averageFloat(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageFloatExtractor(this, valueExtractor));
     }
 
     /**
-     * Combines the given Observables, emitting an item that aggregates the
-     * latest values of each of the source Observables each time an item is
-     * received from any of the source Observables, where this aggregation is
-     * defined by a given function.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into integers by using a function you provide and then emits
+     * the integer average of the complete sequence of transformed values.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            the first source Observable
-     * @param o2
-     *            the second source Observable
-     * @param o3
-     *            the third source Observable
-     * @param o4
-     *            the fourth source Observable
-     * @param o5
-     *            the fifth source Observable
-     * @param o6
-     *            the sixth source Observable
-     * @param o7
-     *            the seventh source Observable
-     * @param o8
-     *            the eighth source Observable
-     * @param o9
-     *            the ninth source Observable
-     * @param combineFunction
-     *            the aggregation function used to combine the
-     *            items emitted by the source Observables
-     * @return an Observable whose emissions are the result of combining the
-     *         emissions of the source Observables with the given aggregation
-     *         function
-     * @see RxJava Wiki: combineLatest()
-     */
-    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));
-    }
-
-    /**
-     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
-     * 
    
-     * Completion of either this or the boundary observable causes the returned observable
-     * to emit the latest buffer and complete.
-     * 
-     * @param 
-     *            the boundary value type (ignored)
-     * @param boundary
-     *            the boundary observable
-     * @return an Observable that emits buffered items once the boundary observable emits an item.
-     * @see #buffer(rx.Observable, int)
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into an integer
+     * @return an Observable that emits the integer average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into integers by the specified function
+     * @see RxJava Wiki: averageInteger()
+     * @see MSDN: Observable.Average
      */
-    public  Observable> buffer(Observable boundary) {
-        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
+    public Observable averageInteger(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageIntegerExtractor(this, valueExtractor));
     }
 
     /**
-     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
+     * Create an Observable that transforms items emitted by the source
+     * Observable into longs by using a function you provide and then emits
+     * the long average of the complete sequence of transformed values.
      * 
    
-     * Completion of either this or the boundary observable causes the returned observable
-     * to emit the latest buffer and complete.
+     * 
      * 
-     * @param 
-     *            the boundary value type (ignored)
-     * @param boundary
-     *            the boundary observable
-     * @param initialCapacity
-     *            the initial capacity of each buffer chunk
-     * @return an Observable that emits buffered items once the boundary observable emits an item.
-     * @see #buffer(rx.Observable, int)
+     * @param valueExtractor
+     *            the function to transform an item emitted by the
+     *            source Observable into a long
+     * @return an Observable that emits the long average of the complete
+     *         sequence of items emitted by the source Observable when
+     *         transformed into longs by the specified function
+     * @see RxJava Wiki: averageLong()
+     * @see MSDN: Observable.Average
      */
-    public  Observable> buffer(Observable boundary, int initialCapacity) {
-        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
+    public Observable averageLong(Func1 valueExtractor) {
+        return create(new OperationAverage.AverageLongExtractor(this, valueExtractor));
     }
 
     /**
@@ -3700,31 +3677,6 @@ public  Observable> buffer(Func0bufferOpenings Observable emits an item,
-     * and closes when the Observable returned from
-     * bufferClosingSelector emits an item.
-     * 
    
-     * 
-     * 
-     * @param bufferOpenings
-     *            the {@link Observable} that, when it emits an item,
-     *            causes a new buffer to be created
-     * @param bufferClosingSelector
-     *            the {@link Func1} that is used to produce
-     *            an {@link Observable} for every buffer
-     *            created. When this {@link Observable} emits
-     *            an item, the associated buffer is emitted.
-     * @return an {@link Observable} that emits buffers that are created and
-     *         closed when the specified {@link Observable}s emit items
-     * @see RxJava Wiki: buffer()
-     */
-    public  Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) {
-        return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
-    }
-
     /**
      * Creates an Observable that emits buffers of items it collects from the
      * source Observable. The resulting Observable emits connected,
@@ -3773,26 +3725,63 @@ public Observable> buffer(int count, int skip) {
 
     /**
      * Creates an Observable that emits buffers of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping buffers, each of a fixed duration specified by the
+     * source Observable. The resulting Observable starts a new buffer
+     * periodically, as determined by the timeshift argument. It
+     * emits buffer after a fixed timespan, specified by the
+     * timespan argument. When the source Observable completes or
+     * encounters an error, it emits the current buffer and propagates the
+     * notification from the source Observable.
+     * 
    
+     * 
+     * 
+     * @param timespan
+     *            the period of time each buffer collects items 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 that applies to the timespan
+     *            and timeshift arguments
+     * @return an {@link Observable} that emits new buffers of items emitted by
+     *         the source Observable periodically after a fixed timespan has
+     *         elapsed
+     * @see RxJava Wiki: buffer()
+     */
+    public Observable> buffer(long timespan, long timeshift, TimeUnit unit) {
+        return create(OperationBuffer.buffer(this, timespan, timeshift, unit));
+    }
+
+    /**
+     * Creates an Observable that emits buffers of items it collects from the
+     * source Observable. The resulting Observable starts a new buffer
+     * periodically, as determined by the timeshift argument. It
+     * emits each buffer after a fixed timespan, specified by the
      * timespan argument. When the source Observable completes or
      * encounters an error, the resulting Observable emits the current buffer
-     * and propagates the notification from the source Observable.
+     * propagates the notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
      * @param timespan
      *            the period of time each buffer collects items before it
-     *            should be emitted and replaced with a new buffer
+     *            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
-     *            argument
-     * @return an {@link Observable} that emits connected, non-overlapping
-     *         buffers with a fixed duration
+     *            the unit of time that applies to the timespan
+     *            and timeshift arguments
+     * @param scheduler
+     *            the {@link Scheduler} to use when determining the end
+     *            and start of a buffer
+     * @return an {@link Observable} that emits new buffers of items emitted by
+     *         the source Observable periodically after a fixed timespan has
+     *         elapsed
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit) {
-        return create(OperationBuffer.buffer(this, timespan, unit));
+    public Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
     }
 
     /**
@@ -3803,7 +3792,7 @@ public Observable> buffer(long timespan, TimeUnit unit) {
      * encounters an error, the resulting Observable emits the current buffer
      * and propagates the notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
      * @param timespan
      *            the period of time each buffer collects items before it
@@ -3811,15 +3800,12 @@ public Observable> buffer(long timespan, TimeUnit unit) {
      * @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} that emits connected, non-overlapping
      *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationBuffer.buffer(this, timespan, unit, scheduler));
+    public Observable> buffer(long timespan, TimeUnit unit) {
+        return create(OperationBuffer.buffer(this, timespan, unit));
     }
 
     /**
@@ -3887,460 +3873,462 @@ public Observable> buffer(long timespan, TimeUnit unit, int count, Sched
 
     /**
      * Creates an Observable that emits buffers of items it collects from the
-     * source Observable. The resulting Observable starts a new buffer
-     * periodically, as determined by the timeshift argument. It
-     * emits buffer after a fixed timespan, specified by the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping buffers, each of a fixed duration specified by the
      * timespan argument. When the source Observable completes or
-     * encounters an error, it emits the current buffer and propagates the
-     * notification from the source Observable.
+     * encounters an error, the resulting Observable emits the current buffer
+     * and propagates the notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
      * @param timespan
      *            the period of time each buffer collects items before it
-     *            should be emitted
-     * @param timeshift
-     *            the period of time after which a new buffer will be
-     *            created
+     *            should be emitted and replaced with a new buffer
      * @param unit
-     *            the unit of time that applies to the timespan
-     *            and timeshift arguments
-     * @return an {@link Observable} that emits new buffers of items emitted by
-     *         the source Observable periodically after a fixed timespan has
-     *         elapsed
+     *            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} that emits connected, non-overlapping
+     *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, long timeshift, TimeUnit unit) {
-        return create(OperationBuffer.buffer(this, timespan, timeshift, unit));
+    public Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationBuffer.buffer(this, timespan, unit, scheduler));
     }
 
     /**
      * Creates an Observable that emits buffers of items it collects from the
-     * source Observable. The resulting Observable starts a new buffer
-     * periodically, as determined by the timeshift argument. It
-     * emits each buffer after a fixed timespan, specified by the
-     * timespan argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current buffer
-     * propagates the notification from the source Observable.
+     * source Observable. The resulting Observable emits buffers that it creates
+     * when the specified bufferOpenings Observable emits an item,
+     * and closes when the Observable returned from
+     * bufferClosingSelector emits an item.
      * 
    
-     * 
+     * 
      * 
-     * @param timespan
-     *            the period of time each buffer collects items 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 that applies to the timespan
-     *            and timeshift arguments
-     * @param scheduler
-     *            the {@link Scheduler} to use when determining the end
-     *            and start of a buffer
-     * @return an {@link Observable} that emits new buffers of items emitted by
-     *         the source Observable periodically after a fixed timespan has
-     *         elapsed
+     * @param bufferOpenings
+     *            the {@link Observable} that, when it emits an item,
+     *            causes a new buffer to be created
+     * @param bufferClosingSelector
+     *            the {@link Func1} that is used to produce
+     *            an {@link Observable} for every buffer
+     *            created. When this {@link Observable} emits
+     *            an item, the associated buffer is emitted.
+     * @return an {@link Observable} that emits buffers that are created and
+     *         closed when the specified {@link Observable}s emit items
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
+    public  Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) {
+        return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows. It emits the current window and opens a new one
-     * when the Observable produced by the specified
-     * closingSelector emits an item. The
-     * closingSelector then creates a new Observable to observe
-     * for the end of the next window.
+     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
      * 
    
-     * 
+     * Completion of either this or the boundary observable causes the returned observable
+     * to emit the latest buffer and complete.
      * 
-     * @param closingSelector
-     *            the {@link Func0} used to produce an {@link Observable} for every window created. When this {@link Observable} emits an item, window() emits
-     *            the associated window and begins a new one.
-     * @return an {@link Observable} that emits connected, non-overlapping
-     *         windows when the current {@link Observable} created with the
-     *         closingSelector argument emits an item
-     * @see RxJava Wiki: window()
+     * @param 
+     *            the boundary value type (ignored)
+     * @param boundary
+     *            the boundary observable
+     * @return an Observable that emits buffered items once the boundary observable emits an item.
+     * @see #buffer(rx.Observable, int)
      */
-    public  Observable> window(Func0> closingSelector) {
-        return create(OperationWindow.window(this, closingSelector));
+    public  Observable> buffer(Observable boundary) {
+        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits windows. These windows
-     * contain those items emitted by the source Observable between the time
-     * when the windowOpenings Observable emits an item and when
-     * the Observable returned by closingSelector emits an item.
+     * Create an Observable that emits non-overlapping buffered items once the boundary observable emits an item.
      * 
    
-     * 
+     * Completion of either this or the boundary observable causes the returned observable
+     * to emit the latest buffer and complete.
      * 
-     * @param windowOpenings
-     *            the {@link Observable} that, when it emits an item,
-     *            causes another window to be created
-     * @param closingSelector
-     *            a {@link Func1} that produces an {@link Observable} for every window created. When
-     *            this {@link Observable} emits an item, the
-     *            associated window is closed and emitted
-     * @return an {@link Observable} that emits windows of items emitted by the
-     *         source Observable that are governed by the specified {@link Observable}s emitting items
-     * @see RxJava Wiki: window()
+     * @param 
+     *            the boundary value type (ignored)
+     * @param boundary
+     *            the boundary observable
+     * @param initialCapacity
+     *            the initial capacity of each buffer chunk
+     * @return an Observable that emits buffered items once the boundary observable emits an item.
+     * @see #buffer(rx.Observable, int)
      */
-    public  Observable> window(Observable windowOpenings, Func1> closingSelector) {
-        return create(OperationWindow.window(this, windowOpenings, closingSelector));
+    public  Observable> buffer(Observable boundary, int initialCapacity) {
+        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
     }
 
     /**
-     * Create an Observable which emits non-overlapping windows of items it collects from the
-     * source observable where the boundary of each window is determined by the items
-     * emitted from the boundary observable.
+     * 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.
+     * 
    
+     * When you call {@code cache()}, it does not yet subscribe to the
+     * source Observable. This only happens when {@code subscribe} is called
+     * the first time on the Observable returned by {@code cache()}.
+     * 
    
+     * 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.
      * 
-     * @param 
-     *            the window element type (ignored)
-     * @param boundary
-     *            the Observable sequence whose emitted item is used for closing
-     *            and opening windows
-     * @return an Observable which emits non-overlapping windows of items it collects from the
-     *         source observable where the boundary of each window is determined by the items
-     *         emitted from the boundary observable
+     * @return an Observable that, when first subscribed to, caches all of its
+     *         items and notifications for the benefit of subsequent observers
+     * @see RxJava Wiki: cache()
      */
-    public  Observable> window(Observable boundary) {
-        return create(OperationWindow.window(this, boundary));
+    public Observable cache() {
+        return create(OperationCache.cache(this));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows, each containing count items. When
-     * the source Observable completes or encounters an error, the resulting
-     * Observable emits the current window and propagates the notification from
-     * the source Observable.
+     * Converts the items emitted by an Observable to the specified type.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the maximum size of each window before it should be emitted
-     * @return an {@link Observable} that emits connected, non-overlapping
-     *         windows containing at most count items
-     * @see RxJava Wiki: window()
+     * @param klass
+     *            the target class type which the items will be converted to
+     * @return an Observable that emits each item from the source Observable
+     *         converted to the specified type
+     * @see RxJava Wiki: cast()
+     * @see MSDN: Observable.Cast
      */
-    public Observable> window(int count) {
-        return create(OperationWindow.window(this, count));
+    public  Observable cast(final Class klass) {
+        return create(OperationCast.cast(this, klass));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits windows every
-     * skip items, each containing count items.
-     * When the source Observable completes or encounters an error, the
-     * resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Collect values into a single mutable data structure.
+     * 
    
+     * A simplified version of `reduce` that does not need to return the state on each pass.
      * 
    
-     * 
      * 
-     * @param count
-     *            the maximum size of each window before it should be emitted
-     * @param skip
-     *            how many items need to be skipped before starting a new
-     *            window. Note that if skip and count
-     *            are equal this is the same operation as {@link #window(int)}.
-     * @return an {@link Observable} that emits windows every "skipped"
-     *         items containing at most count items
-     * @see RxJava Wiki: window()
+     * @param state
+     * @param collector
+     * @return
      */
-    public Observable> window(int count, int skip) {
-        return create(OperationWindow.window(this, count, skip));
+    public  Observable collect(R state, final Action2 collector) {
+        Func2 accumulator = new Func2() {
+
+            @Override
+            public R call(R state, T value) {
+                collector.call(state, value);
+                return state;
+            }
+
+        };
+        return reduce(state, accumulator);
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows, each of a fixed duration specified by the
-     * timespan argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current window
-     * and propagates the notification from the source Observable.
+     * 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 concatting those resulting Observables and emitting
+     * the results of this concat.
      * 
    
-     * 
+     * 
      * 
-     * @param timespan
-     *            the period of time each window collects items before it
-     *            should be emitted and replaced with a new window
-     * @param unit
-     *            the unit of time that applies to the timespan
-     *            argument
-     * @return an {@link Observable} that emits connected, non-overlapping
-     *         windows with a fixed duration
-     * @see RxJava Wiki: window()
+     * @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 concatting the results of the Observables obtained
+     *         from this transformation.
      */
-    public Observable> window(long timespan, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, unit));
+    public  Observable concatMap(Func1> func) {
+        return concat(map(func));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows, each of a fixed duration as specified by the
-     * timespan argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current window
-     * and propagates the notification from the source Observable.
+     * Returns an Observable that emits a Boolean that indicates whether the
+     * source Observable emitted a specified item.
      * 
    
-     * 
+     * 
      * 
-     * @param timespan
-     *            the period of time each window collects items 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} that emits connected, non-overlapping
-     *         windows with a fixed duration
-     * @see RxJava Wiki: window()
+     * @param element
+     *            the item to search for in the emissions from the source
+     *            Observable
+     * @return an Observable that emits true if the specified item
+     *         is emitted by the source Observable, or false if the
+     *         source Observable completes without emitting that item
+     * @see RxJava Wiki: contains()
+     * @see MSDN: Observable.Contains
      */
-    public Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, scheduler));
+    public Observable contains(final T element) {
+        return exists(new Func1() {
+            public Boolean call(T t1) {
+                return element == null ? t1 == null : element.equals(t1);
+            }
+        });
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows, each of a fixed duration as specified by the
-     * timespan argument or a maximum size as specified by the
-     * count argument (whichever is reached first). When the source
-     * Observable completes or encounters an error, the resulting Observable
-     * emits the current window and propagates the notification from the source
-     * Observable.
+     * Returns an Observable emits the count of the total number of items
+     * emitted by the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param timespan
-     *            the period of time each window collects items before it
-     *            should be emitted and replaced with a new window
-     * @param unit
-     *            the unit of time that applies to the timespan
-     *            argument
-     * @param count
-     *            the maximum size of each window before it should be emitted
-     * @return an {@link Observable} that emits connected, non-overlapping
-     *         windows after a fixed duration or when the window has reached
-     *         maximum capacity (whichever occurs first)
-     * @see RxJava Wiki: window()
+     * @return an Observable that emits the number of elements emitted by the
+     *         source Observable as its single item
+     * @see RxJava Wiki: count()
+     * @see MSDN: Observable.Count
+     * @see #longCount()
      */
-    public Observable> window(long timespan, TimeUnit unit, int count) {
-        return create(OperationWindow.window(this, timespan, unit, count));
+    public Observable count() {
+        return reduce(0, new Func2() {
+            @Override
+            public Integer call(Integer t1, T t2) {
+                return t1 + 1;
+            }
+        });
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable emits connected,
-     * non-overlapping windows, each of a fixed duration specified by the
-     * timespan argument or a maximum size specified by the
-     * count argument (whichever is reached first). When the source
-     * Observable completes or encounters an error, the resulting Observable
-     * emits the current window and propagates the notification from the source
-     * Observable.
-     * 
    
-     * 
+     * Create an Observable that ignores elements from this observable
+     * sequence which are followed by another value within a computed
+     * debounce duration.
      * 
-     * @param timespan
-     *            the period of time each window collects items 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} that emits connected non-overlapping
-     *         windows after a fixed duration or when the window has reached
-     *         maximum capacity (whichever occurs first).
-     * @see RxJava Wiki: window()
+     * @param 
+     *            the debounce value type (ignored)
+     * @param debounceSelector
+     *            function to retrieve a sequence indicating the throttle duration for each given element.
+     * @return an Observable that ignores elements from this observable
+     *         sequence which are followed by another value within a computed
+     *         debounce duration
      */
-    public Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, count, scheduler));
+    public  Observable debounce(Func1> debounceSelector) {
+        return create(OperationDebounce.debounceSelector(this, debounceSelector));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable starts a new window
-     * periodically, as determined by the timeshift argument. It
-     * emits each window after a fixed timespan, specified by the
-     * timespan argument. When the source Observable completes or
-     * Observable completes or encounters an error, the resulting Observable
-     * emits the current window and propagates the notification from the source
-     * Observable.
+     * Drops items emitted by an Observable that are followed by newer items
+     * before a timeout value expires. The timer resets on each emission.
      * 
    
-     * 
+     * Note: If events keep firing faster than the timeout then no items will be
+     * emitted by the resulting Observable.
+     * 
    
+     * 
+     * 
    
+     * Information on debounce vs throttle:
+     * 
    
+     * 
    
      * 
-     * @param timespan
-     *            the period of time each window collects items before it
-     *            should be emitted
-     * @param timeshift
-     *            the period of time after which a new window will be
-     *            created
+     * @param timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
      * @param unit
-     *            the unit of time that applies to the timespan
-     *            and timeshift arguments
-     * @return an {@link Observable} that emits new windows periodically as a
-     *         fixed timespan has elapsed
-     * @see RxJava Wiki: window()
+     *            the {@link TimeUnit} for the timeout
+     * @return an {@link Observable} that filters out items that are too quickly
+     *         followed by newer items
+     * @see RxJava Wiki: debounce()
+     * @see #throttleWithTimeout(long, TimeUnit)
      */
-    public Observable> window(long timespan, long timeshift, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit));
+    public Observable debounce(long timeout, TimeUnit unit) {
+        return create(OperationDebounce.debounce(this, timeout, unit));
     }
 
     /**
-     * Creates an Observable that emits windows of items it collects from the
-     * source Observable. The resulting Observable starts a new window
-     * periodically, as determined by the timeshift argument. It
-     * emits each window after a fixed timespan, specified by the
-     * timespan argument. When the source Observable completes or
-     * Observable completes or encounters an error, the resulting Observable
-     * emits the current window and propagates the notification from the source
-     * Observable.
+     * Drops items emitted by an Observable that are followed by newer items
+     * before a timeout value expires. The timer resets on each emission.
      * 
    
-     * 
+     * Note: If events keep firing faster than the timeout then no items will be
+     * emitted by the resulting Observable.
+     * 
    
+     * 
+     * 
    
+     * Information on debounce vs throttle:
+     * 
    
+     * 
    
      * 
-     * @param timespan
-     *            the period of time each window collects items before it
-     *            should be emitted
-     * @param timeshift
-     *            the period of time after which a new window will be
-     *            created
+     * @param timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
      * @param unit
-     *            the unit of time that applies to the timespan
-     *            and timeshift arguments
+     *            the unit of time for the specified timeout
      * @param scheduler
-     *            the {@link Scheduler} to use when determining the end
-     *            and start of a window
-     * @return an {@link Observable} that emits new windows periodically as a
-     *         fixed timespan has elapsed
-     * @see RxJava Wiki: window()
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle the timeout for each event
+     * @return an {@link Observable} that filters out items that are too quickly
+     *         followed by newer items
+     * @see RxJava Wiki: debounce()
+     * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
      */
-    public Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
+    public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationDebounce.debounce(this, timeout, 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 source Observables; 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.
+     * Returns an Observable that emits the items emitted by the source
+     * Observable or a specified default item if the source Observable is empty.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: zip()
+     * @param defaultValue
+     *            the item to emit if the source Observable emits no
+     *            items
+     * @return an Observable that emits either the specified default item if the
+     *         source Observable emits no items, or the items emitted by the
+     *         source Observable
+     * @see RxJava Wiki: defaultIfEmpty()
+     * @see MSDN: Observable.DefaultIfEmpty
      */
-    public static  Observable zip(Observable> ws, final FuncN zipFunction) {
-        return ws.toList().mergeMap(new Func1>, Observable>() {
-            @Override
-            public Observable call(List> wsList) {
-                return create(OperationZip.zip(wsList, zipFunction));
-            }
-        });
+    public Observable defaultIfEmpty(T defaultValue) {
+        return create(OperationDefaultIfEmpty.defaultIfEmpty(this, defaultValue));
     }
 
     /**
-     * Returns an Observable that emits the results of a function of your
-     * choosing applied to combinations items emitted, in sequence, by a
-     * collection of 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 source Observables; 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.
+     * Create an Observable which delays the subscription and events via another Observables on a per item-basis.
      * 
    
-     * 
+     * Note: onError event is immediately propagated.
      * 
-     * @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
-     * @see RxJava Wiki: zip()
+     * @param 
+     *            the subscription delay value type (ignored)
+     * @param 
+     *            the item delay value type (ignored)
+     * @param subscriptionDelay
+     *            function that returns an Observable which will trigger
+     *            the subscription to the source observable once it fires an
+     *            onNext event.
+     * @param itemDelay
+     *            function that returns an Observable for each source item which is
+     *            then used for delaying that particular item until the Observable
+     *            fires its first onNext event.
+     * @return an Observable which delays the events via another Observable on a per item-basis.
      */
-    public static  Observable zip(Iterable> ws, FuncN zipFunction) {
-        return create(OperationZip.zip(ws, zipFunction));
+    public  Observable delay(
+            Func0> subscriptionDelay,
+            Func1> itemDelay) {
+        return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
     }
 
     /**
-     * Filter items emitted by an Observable.
+     * Create an Observable which delays the events via another Observable on a per item-basis.
      * 
    
-     * 
+     * Note: onError event is immediately propagated.
      * 
-     * @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 emitted by the source
-     *         Observable that the filter evaluates as {@code true}
-     * @see RxJava Wiki: filter()
+     * @param 
+     *            the item delay value type (ignored)
+     * @param itemDelay
+     *            function that returns an Observable for each source item which is
+     *            then used for delaying that particular item until the Observable
+     *            fires its first onNext event.
+     * @return an Observable which delays the events via another Observable on a per item-basis.
      */
-    public Observable filter(Func1 predicate) {
-        return create(OperationFilter.filter(this, predicate));
+    public  Observable delay(Func1> itemDelay) {
+        return create(OperationDelay.delay(this, itemDelay));
     }
 
     /**
-     * Returns an Observable that emits all sequentially distinct items
-     * emitted by the source Observable.
+     * Returns an Observable that emits the items emitted by the source
+     * Observable shifted forward in time by a specified delay. Error
+     * notifications from the source Observable are not delayed.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits those items from the source Observable
-     *         that are sequentially distinct
-     * @see RxJava Wiki: distinctUntilChanged()
-     * @see MSDN: Observable.distinctUntilChanged
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            the {@link TimeUnit} in which period is defined
+     * @return the source Observable, but shifted by the specified delay
+     * @see RxJava Wiki: delay()
+     * @see MSDN: Observable.Delay
      */
-    public Observable distinctUntilChanged() {
-        return create(OperationDistinctUntilChanged.distinctUntilChanged(this));
+    public Observable delay(long delay, TimeUnit unit) {
+        return OperationDelay.delay(this, delay, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Returns an Observable that emits all items emitted by the source
-     * Observable that are sequentially distinct according to a key selector
-     * function.
-     * 
    
-     * 
+     * Returns an Observable that emits the items emitted by the source
+     * Observable shifted forward in time by a specified delay. Error
+     * notifications from the source Observable are not delayed.
+     * 
    
+     * 
      * 
-     * @param keySelector
-     *            a function that projects an emitted item to a key
-     *            value that is used to decide whether an item is
-     *            sequentially distinct from another one or not
-     * @return an Observable that emits those items from the source Observable
-     *         whose keys are sequentially distinct
-     * @see RxJava Wiki: distinctUntilChanged()
-     * @see MSDN: Observable.distinctUntilChanged
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            the {@link TimeUnit} in which period is defined
+     * @param scheduler
+     *            the {@link Scheduler} to use for delaying
+     * @return the source Observable, but shifted by the specified delay
+     * @see RxJava Wiki: delay()
+     * @see MSDN: Observable.Delay
      */
-    public  Observable distinctUntilChanged(Func1 keySelector) {
-        return create(OperationDistinctUntilChanged.distinctUntilChanged(this, keySelector));
+    public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
+        return OperationDelay.delay(this, delay, unit, scheduler);
+    }
+
+    /**
+     * Return an Observable that delays the subscription to the source
+     * Observable by a given amount of time.
+     * 
    
+     * 
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit
+     * @return an Observable that delays the subscription to the source
+     *         Observable by the given amount
+     */
+    public Observable delaySubscription(long delay, TimeUnit unit) {
+        return delaySubscription(delay, unit, Schedulers.threadPoolForComputation());
+    }
+
+    /**
+     * Return an Observable that delays the subscription to the source
+     * Observable by a given amount of time, both waiting and subscribing on
+     * a given Scheduler.
+     * 
    
+     * 
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler on which the waiting and subscription will
+     *            happen
+     * @return an Observable that delays the subscription to the source
+     *         Observable by a given amount, waiting and subscribing on the
+     *         given Scheduler
+     */
+    public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationDelay.delaySubscription(this, delay, unit, 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
+     * @throws Throwable
+     *             if the source Observable is not of type {@code Observable>}
+     * @see RxJava Wiki: dematerialize()
+     * @see MSDN: Observable.dematerialize
+     */
+    @SuppressWarnings("unchecked")
+    public  Observable dematerialize() {
+        return create(OperationDematerialize.dematerialize((Observable>) this));
     }
 
     /**
@@ -4378,341 +4366,370 @@ public  Observable distinct(Func1 keySelector) {
     }
 
     /**
-     * Returns an Observable that emits the item at a specified index in a
-     * sequence of emissions from a source Observbable.
+     * Returns an Observable that emits all sequentially distinct items
+     * emitted by the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param index
-     *            the zero-based index of the item to retrieve
-     * @return an Observable that emits the item at the specified position in
-     *         the sequence of those emitted by the source Observable
-     * @throws IndexOutOfBoundsException
-     *             if index is greater than
-     *             or equal to the number of items emitted
-     *             by the source Observable
-     * @throws IndexOutOfBoundsException
-     *             if index is less than 0
-     * @see RxJava Wiki: elementAt()
+     * @return an Observable that emits those items from the source Observable
+     *         that are sequentially distinct
+     * @see RxJava Wiki: distinctUntilChanged()
+     * @see MSDN: Observable.distinctUntilChanged
      */
-    public Observable elementAt(int index) {
-        return create(OperationElementAt.elementAt(this, index));
+    public Observable distinctUntilChanged() {
+        return create(OperationDistinctUntilChanged.distinctUntilChanged(this));
     }
 
     /**
-     * Returns the item at a specified index in a sequence or the default item
-     * if the index is out of range.
+     * Returns an Observable that emits all items emitted by the source
+     * Observable that are sequentially distinct according to a key selector
+     * function.
      * 
    
-     * 
+     * 
      * 
-     * @param index
-     *            the zero-based index of the item to retrieve
-     * @param defaultValue
-     *            the default item
-     * @return an Observable that emits the item at the specified position in
-     *         the source sequence, or the default item if the index is outside
-     *         the bounds of the source sequence
-     * @throws IndexOutOfBoundsException
-     *             if index is less than 0
-     * @see RxJava Wiki: elementAtOrDefault()
+     * @param keySelector
+     *            a function that projects an emitted item to a key
+     *            value that is used to decide whether an item is
+     *            sequentially distinct from another one or not
+     * @return an Observable that emits those items from the source Observable
+     *         whose keys are sequentially distinct
+     * @see RxJava Wiki: distinctUntilChanged()
+     * @see MSDN: Observable.distinctUntilChanged
      */
-    public Observable elementAtOrDefault(int index, T defaultValue) {
-        return create(OperationElementAt.elementAtOrDefault(this, index, defaultValue));
+    public  Observable distinctUntilChanged(Func1 keySelector) {
+        return create(OperationDistinctUntilChanged.distinctUntilChanged(this, keySelector));
     }
 
     /**
-     * Returns an {@link Observable} that emits true if any item
-     * emitted by the source {@link Observable} satisfies a specified condition,
-     * otherwise false. Note: this always emits false
-     * if the source {@link Observable} is empty.
-     * 
    
-     * In Rx.Net this is the any operator but we renamed it in
-     * RxJava to better match Java naming idioms.
+     * Invokes an action when the source Observable calls
+     * onCompleted.
      * 
    
-     * 
+     * 
      * 
-     * @param predicate
-     *            the condition to test every item emitted by the source
-     *            Observable
-     * @return a subscription function for creating the target Observable
-     * @see RxJava Wiki: exists()
-     * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
+     * @param onCompleted
+     *            the action to invoke when the source Observable calls
+     *            onCompleted
+     * @return the source Observable with the side-effecting behavior applied
+     * @see RxJava Wiki: doOnCompleted()
+     * @see MSDN: Observable.Do
      */
-    public Observable exists(Func1 predicate) {
-        return create(OperationAny.exists(this, predicate));
+    public Observable doOnCompleted(final Action0 onCompleted) {
+        Observer observer = new Observer() {
+            @Override
+            public void onCompleted() {
+                onCompleted.call();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onNext(T args) {
+            }
+
+        };
+
+        return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
     /**
-     * Returns an Observable that emits a Boolean that indicates whether the
-     * source Observable emitted a specified item.
+     * Invokes an action for each item emitted by the Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param element
-     *            the item to search for in the emissions from the source
+     * @param observer
+     *            the action to invoke for each item emitted by the source
      *            Observable
-     * @return an Observable that emits true if the specified item
-     *         is emitted by the source Observable, or false if the
-     *         source Observable completes without emitting that item
-     * @see RxJava Wiki: contains()
-     * @see MSDN: Observable.Contains
+     * @return the source Observable with the side-effecting behavior applied
+     * @see RxJava Wiki: doOnEach()
+     * @see MSDN: Observable.Do
      */
-    public Observable contains(final T element) {
-        return exists(new Func1() {
-            public Boolean call(T t1) {
-                return element == null ? t1 == null : element.equals(t1);
+    public Observable doOnEach(final Action1> onNotification) {
+        Observer observer = new Observer() {
+            @Override
+            public void onCompleted() {
+                onNotification.call(new Notification());
             }
-        });
+
+            @Override
+            public void onError(Throwable e) {
+                onNotification.call(new Notification(e));
+            }
+
+            @Override
+            public void onNext(T v) {
+                onNotification.call(new Notification(v));
+            }
+
+        };
+
+        return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
     /**
-     * Registers an {@link Action0} to be called when this Observable invokes {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}.
+     * Invokes an action for each item emitted by the Observable.
      * 
    
-     * 
+     * 
      * 
-     * @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 RxJava Wiki: finallyDo()
-     * @see MSDN: Observable.Finally
+     * @param observer
+     *            the action to invoke for each item emitted by the source
+     *            Observable
+     * @return the source Observable with the side-effecting behavior applied
+     * @see RxJava Wiki: doOnEach()
+     * @see MSDN: Observable.Do
      */
-    public Observable finallyDo(Action0 action) {
-        return create(OperationFinally.finallyDo(this, action));
+    public Observable doOnEach(Observer observer) {
+        return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
     /**
-     * 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.
-     * 
    
-     * 
+     * Invokes an action if the source Observable calls onError.
      * 
    
-     * 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 RxJava Wiki: flatMap()
-     * @see #mapMany(Func1)
+     * @param onError
+     *            the action to invoke if the source Observable calls
+     *            onError
+     * @return the source Observable with the side-effecting behavior applied
+     * @see RxJava Wiki: doOnError()
+     * @see MSDN: Observable.Do
      */
-    public  Observable flatMap(Func1> func) {
-        return mergeMap(func);
+    public Observable doOnError(final Action1 onError) {
+        Observer observer = new Observer() {
+            @Override
+            public void onCompleted() {
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                onError.call(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+            }
+
+        };
+
+        return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
     /**
-     * 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.
+     * Invokes an action when the source Observable calls
+     * onNext.
      * 
    
-     * 
+     * 
      * 
-     * @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 RxJava Wiki: flatMap()
-     * @see #flatMap(Func1)
+     * @param onNext
+     *            the action to invoke when the source Observable calls
+     *            onNext
+     * @return the source Observable with the side-effecting behavior applied
+     * @see RxJava Wiki: doOnNext()
+     * @see MSDN: Observable.Do
      */
-    public  Observable mergeMap(Func1> func) {
-        return merge(map(func));
-    }
+    public Observable doOnNext(final Action1 onNext) {
+        Observer observer = new Observer() {
+            @Override
+            public void onCompleted() {
+            }
 
-    /**
-     * Create an Observable that applies a function to the pair of values from the source
-     * Observable and the collection Observable.
-     * 
-     * @param 
-     *            the element type of the collection Observable
-     * @param 
-     *            the result type
-     * @param collectionSelector
-     *            function that returns an Observable sequence for each value in the source Observable
-     * @param resultSelector
-     *            function that combines the values of the source and collection Observable
-     * @return an Observable that applies a function to the pair of values from the source
-     *         Observable and the collection Observable.
-     */
-    public  Observable mergeMap(Func1> collectionSelector,
-            Func2 resultSelector) {
-        return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
-    }
+            @Override
+            public void onError(Throwable e) {
+            }
 
-    /**
-     * Create an Observable that merges the values of the iterables returned by the
-     * collectionSelector for each source value.
-     * 
-     * @param 
-     *            the result value type
-     * @param collectionSelector
-     *            function that returns an Iterable sequence of values for
-     *            each source value.
-     * @return an Observable that merges the values of the iterables returned by the
-     *         collectionSelector for each source value.
-     */
-    public  Observable mergeMapIterable(Func1> collectionSelector) {
-        return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
-    }
+            @Override
+            public void onNext(T args) {
+                onNext.call(args);
+            }
 
-    /**
-     * Create an Observable that applies a function to the pair of values from the source
-     * Observable and the collection Iterable sequence.
-     * 
-     * @param 
-     *            the collection element type
-     * @param 
-     *            the result type
-     * @param collectionSelector
-     *            function that returns an Iterable sequence of values for
-     *            each source value.
-     * @param resultSelector
-     *            function that combines the values of the source and collection Iterable
-     * @return n Observable that applies a function to the pair of values from the source
-     *         Observable and the collection Iterable sequence.
-     */
-    public  Observable mergeMapIterable(Func1> collectionSelector,
-            Func2 resultSelector) {
-        return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
+        };
+
+        return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
     /**
-     * Create an Observable that projects the notification of an observable sequence to an observable
-     * sequence and merges the results into one.
+     * Returns an Observable that emits the item at a specified index in a
+     * sequence of emissions from a source Observbable.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the result type
-     * @param onNext
-     *            function returning a collection to merge for each onNext event of the source
-     * @param onError
-     *            function returning a collection to merge for an onError event
-     * @param onCompleted
-     *            function returning a collection to merge for an onCompleted event
-     * @return an Observable that projects the notification of an observable sequence to an observable
-     *         sequence and merges the results into one.
+     * @param index
+     *            the zero-based index of the item to retrieve
+     * @return an Observable that emits the item at the specified position in
+     *         the sequence of those emitted by the source Observable
+     * @throws IndexOutOfBoundsException
+     *             if index is greater than
+     *             or equal to the number of items emitted
+     *             by the source Observable
+     * @throws IndexOutOfBoundsException
+     *             if index is less than 0
+     * @see RxJava Wiki: elementAt()
      */
-    public  Observable mergeMap(
-            Func1> onNext,
-            Func1> onError,
-            Func0> onCompleted) {
-        return create(OperationFlatMap.flatMap(this, onNext, onError, onCompleted));
+    public Observable elementAt(int index) {
+        return create(OperationElementAt.elementAt(this, index));
     }
 
     /**
-     * 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 concatting those resulting Observables and emitting
-     * the results of this concat.
+     * Returns the item at a specified index in a sequence or the default item
+     * if the index is out of range.
      * 
    
-     * 
+     * 
      * 
-     * @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 concatting the results of the Observables obtained
-     *         from this transformation.
+     * @param index
+     *            the zero-based index of the item to retrieve
+     * @param defaultValue
+     *            the default item
+     * @return an Observable that emits the item at the specified position in
+     *         the source sequence, or the default item if the index is outside
+     *         the bounds of the source sequence
+     * @throws IndexOutOfBoundsException
+     *             if index is less than 0
+     * @see RxJava Wiki: elementAtOrDefault()
      */
-    public  Observable concatMap(Func1> func) {
-        return concat(map(func));
+    public Observable elementAtOrDefault(int index, T defaultValue) {
+        return create(OperationElementAt.elementAtOrDefault(this, index, defaultValue));
     }
 
     /**
-     * Creates a new Observable by applying a function that you supply to each
-     * item emitted by the source Observable resulting in an Observable of
-     * Observables. Then a {@link #switchLatest(Observable)} / {@link #switchOnNext(Observable)} is applied.
+     * Returns an {@link Observable} that emits true if any item
+     * emitted by the source {@link Observable} satisfies a specified condition,
+     * otherwise false. Note: this always emits false
+     * if the source {@link Observable} is empty.
      * 
    
-     * 
+     * In Rx.Net this is the any operator but we renamed it in
+     * RxJava to better match Java naming idioms.
+     * 
    
+     * 
      * 
-     * @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 then switch
+     * @param predicate
+     *            the condition to test every item emitted by the source
+     *            Observable
+     * @return a subscription function for creating the target Observable
+     * @see RxJava Wiki: exists()
+     * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
      */
-    public  Observable switchMap(Func1> func) {
-        return switchOnNext(map(func));
+    public Observable exists(Func1 predicate) {
+        return create(OperationAny.exists(this, predicate));
     }
 
     /**
      * Filter items emitted by an Observable.
      * 
    
-     * 
+     * 
      * 
      * @param predicate
-     *            a function that evaluates an item emitted by the source
-     *            Observable, returning {@code true} if it passes the
-     *            filter
+     *            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 emitted by the source
      *         Observable that the filter evaluates as {@code true}
-     * @see RxJava Wiki: where()
-     * @see #filter(Func1)
+     * @see RxJava Wiki: filter()
      */
-    @Deprecated
-    public Observable where(Func1 predicate) {
-        return filter(predicate);
+    public Observable filter(Func1 predicate) {
+        return create(OperationFilter.filter(this, predicate));
     }
 
     /**
-     * Returns an Observable that applies the given function to each item
-     * emitted by an Observable and emits the results of these function
-     * applications.
+     * Registers an {@link Action0} to be called when this Observable invokes {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: map()
-     * @see MSDN: Observable.Select
+     * @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 RxJava Wiki: finallyDo()
+     * @see MSDN: Observable.Finally
      */
-    public  Observable map(Func1 func) {
-        return create(OperationMap.map(this, func));
+    public Observable finallyDo(Action0 action) {
+        return create(OperationFinally.finallyDo(this, action));
     }
 
     /**
-     * Returns an Observable that applies the given function to each item
-     * emitted by an Observable and emits the results of these function
-     * applications.
+     * Returns an Observable that emits only the very first item emitted by the
+     * source Observable, or an IllegalArgumentException if the
+     * source {@link Observable} is empty.
      * 
    
-     * 
+     * 
      * 
-     * @param func
-     *            a function to apply to each item emitted by the Observable
-     *            that takes the index of the emitted item as additional
-     *            parameter
-     * @return an Observable that emits the items from the source Observable,
-     *         transformed by the given function
-     * @see RxJava Wiki: mapWithIndex()
-     * @see MSDN: Observable.Select
-     * @deprecated just use zip with {@link Observable#range(int)}
+     * @return an Observable that emits only the very first item from the
+     *         source, or an IllegalArgumentException if the source {@link Observable} is empty.
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
      */
-    @Deprecated
-    public  Observable mapWithIndex(Func2 func) {
-        return create(OperationMap.mapWithIndex(this, func));
+    public Observable first() {
+        return take(1).single();
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the
+     * source Observable that satisfies a given condition, or an
+     * IllegalArgumentException if no such items are emitted.
+     * 
    
+     * 
+     * 
+     * @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 an IllegalArgumentException if no such items are emitted.
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
+     */
+    public Observable first(Func1 predicate) {
+        return takeFirst(predicate).single();
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the
+     * source Observable, or a default item.
+     * 
    
+     * 
+     * 
+     * @param defaultValue
+     *            the default item 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 item if the source Observable completes
+     *         without emitting a single item
+     * @see RxJava Wiki: firstOrDefault()
+     * @see MSDN: Observable.firstOrDefaultAsync()
+     */
+    public Observable firstOrDefault(T defaultValue) {
+        return take(1).singleOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the
+     * source Observable that satisfies a given condition, or a default item
+     * otherwise.
+     * 
    
+     * 
+     * 
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
+     * @param defaultValue
+     *            the default item 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 item otherwise
+     * @see RxJava Wiki: firstOrDefault()
+     * @see MSDN: Observable.firstOrDefaultAsync()
+     */
+    public Observable firstOrDefault(T defaultValue, Func1 predicate) {
+        return takeFirst(predicate).singleOrDefault(defaultValue);
     }
 
     /**
      * 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.
+     * Observable, and then merging those resulting Observables and emitting the
+     * results of this merger.
      * 
    
-     * 
+     * 
      * 
    
-     * Note: mapMany and flatMap are equivalent.
+     * Note: {@code mapMany} and {@code flatMap} are equivalent.
      * 
      * @param func
      *            a function that, when applied to an item emitted by the
@@ -4721,597 +4738,534 @@ public  Observable mapWithIndex(Func2 fun
      *         transformation function to each item emitted by the source
      *         Observable and merging the results of the Observables obtained
      *         from this transformation.
-     * @see RxJava Wiki: mapMany()
-     * @see #flatMap(Func1)
-     * @deprecated
+     * @see RxJava Wiki: flatMap()
+     * @see #mapMany(Func1)
      */
-    @Deprecated
-    public  Observable mapMany(Func1> func) {
+    public  Observable flatMap(Func1> func) {
         return mergeMap(func);
     }
 
     /**
-     * Turns all of the emissions and notifications from a source Observable
-     * into emissions marked with their original types within {@link Notification} objects.
+     * 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.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable whose items are the result of materializing the
-     *         items and notifications of the source Observable
-     * @see RxJava Wiki: materialize()
-     * @see MSDN: Observable.materialize
+     * @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
+     * @see RxJava Wiki: groupBy
      */
-    public Observable> materialize() {
-        return create(OperationMaterialize.materialize(this));
+    public  Observable> groupBy(final Func1 keySelector) {
+        return create(OperationGroupBy.groupBy(this, keySelector));
     }
 
     /**
-     * Asynchronously subscribes and unsubscribes Observers on the specified {@link Scheduler}.
+     * 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 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}
-     * @see RxJava Wiki: subscribeOn()
+     * @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
+     * @see RxJava Wiki: groupBy
      */
-    public Observable subscribeOn(Scheduler scheduler) {
-        return create(OperationSubscribeOn.subscribeOn(this, scheduler));
+    public  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
+        return create(OperationGroupBy.groupBy(this, keySelector, elementSelector));
     }
 
     /**
-     * Asynchronously notify {@link Observer}s on the specified {@link Scheduler}.
+     * Groups the items emitted by an Observable according to a specified key
+     * selector function until the duration Observable expires for the key.
      * 
    
-     * 
+     * 
      * 
-     * @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}
-     * @see RxJava Wiki: observeOn()
+     * @param keySelector
+     *            a function to extract the key for each item
+     * @param durationSelector
+     *            a function to signal the expiration of a group
+     * @return an Observable that emits grouped Observables, each of which
+     *         corresponds to a key value and emits all items that share that
+     *         same key value that were emitted during the key's duration
+     * @see RxJava Wiki: groupByUntil()
+     * @see MSDN: Observable.GroupByUntil
      */
-    public Observable observeOn(Scheduler scheduler) {
-        return create(OperationObserveOn.observeOn(this, scheduler));
+    public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
+        return groupByUntil(keySelector, Functions. identity(), durationSelector);
     }
 
     /**
-     * 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.
+     * Groups the items emitted by an Observable according to specified key and
+     * value selector functions until the duration Observable expires for the
+     * key.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits the items and notifications embedded in
-     *         the {@link Notification} objects emitted by the source Observable
-     * @throws Throwable
-     *             if the source Observable is not of type {@code Observable>}
-     * @see RxJava Wiki: dematerialize()
-     * @see MSDN: Observable.dematerialize
+     * @param keySelector
+     *            a function to extract the key for each item
+     * @param valueSelector
+     *            a function to map each source item to an item
+     *            emitted by an Observable group
+     * @param durationSelector
+     *            a function to signal the expiration of a group
+     * @return an Observable that emits grouped Observables, each of which
+     *         corresponds to a key value and emits all items that share that
+     *         same key value that were emitted during the key's duration
+     * @see RxJava Wiki: groupByUntil()
+     * @see MSDN: Observable.GroupByUntil
      */
-    @SuppressWarnings("unchecked")
-    public  Observable dematerialize() {
-        return create(OperationDematerialize.dematerialize((Observable>) this));
+    public  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
+        return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector));
     }
 
     /**
-     * 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.
+     * Return an Observable that correlates two sequences when they overlap and
+     * groups the results.
      * 
    
-     * 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
-     * @see RxJava Wiki: onErrorResumeNext()
+     * @param right
+     *            the other Observable to correlate items from this Observable
+     *            with
+     * @param leftDuration
+     *            function that returns an Observable whose emissions
+     *            indicate the duration of the values of this
+     *            Observable
+     * @param rightDuration
+     *            function that returns an Observable whose emissions
+     *            indicate the duration of the values of the
+     *            right Observable
+     * @param resultSelector
+     *            function that takes an item emitted by each source
+     *            Observable and returns the value to be emitted by
+     *            the resulting Observable
+     * @return an Observable that emits grouped items based on overlapping
+     *         durations from this and another Observable
+     * @see RxJava Wiiki: groupJoin
+     * @see MSDN: Observable.GroupJoin
      */
-    public Observable onErrorResumeNext(final Func1> resumeFunction) {
-        return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
-    }
+    public  Observable groupJoin(Observable right, Func1> leftDuration,
+            Func1> rightDuration,
+            Func2, ? extends R> resultSelector) {
+        return create(new OperationGroupJoin(this, right, leftDuration, rightDuration, resultSelector));
+    }
 
     /**
-     * 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.
+     * Ignores all items emitted by an Observable and only calls
+     * onCompleted or onError.
      * 
    
-     * 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
-     * @see RxJava Wiki: onErrorResumeNext()
+     * @return an empty Observable that only calls onCompleted or
+     *         onError
+     * @see RxJava Wiki: ignoreElements()
+     * @see MSDN: Observable.IgnoreElements
      */
-    public Observable onErrorResumeNext(final Observable resumeSequence) {
-        return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
+    public Observable ignoreElements() {
+        return filter(alwaysFalse());
     }
 
     /**
-     * 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.
-     * 
    
-     * 
+     * Returns an Observable that emits true if the source
+     * Observable is empty, otherwise false.
      * 
    
-     * 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.
+     * In Rx.Net this is negated as the any operator but we renamed
+     * this in RxJava to better match Java naming idioms.
      * 
    
-     * 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
-     * @see RxJava Wiki: onExceptionResumeNextViaObservable()
+     * @return an Observable that emits a Boolean
+     * @see RxJava Wiki: isEmpty()
+     * @see MSDN: Observable.Any
      */
-    public Observable onExceptionResumeNext(final Observable resumeSequence) {
-        return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
+    public Observable isEmpty() {
+        return create(OperationAny.isEmpty(this));
     }
 
     /**
-     * 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 emit the return value of resumeFunction.
+     * Correlates the items emitted by two Observables based on overlapping
+     * durations.
      * 
    
-     * 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
-     * @see RxJava Wiki: onErrorReturn()
+     * @param right
+     *            the second Observable to join items from
+     * @param leftDurationSelector
+     *            a function to select the duration of each
+     *            item emitted by this Observable, used to
+     *            determine overlap
+     * @param rightDurationSelector
+     *            a function to select the duration of each
+     *            item emitted by the right
+     *            Observable, used to determine overlap
+     * @param resultSelector
+     *            a function that computes a result item for any two
+     *            overlapping items emitted by the two Observables
+     * @return an Observable that emits result items computed from source items
+     *         that have an overlapping duration
+     * @see RxJava Wiki: join()
+     * @see MSDN: Observable.Join
      */
-    public Observable onErrorReturn(Func1 resumeFunction) {
-        return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
+    public  Observable join(Observable right, Func1> leftDurationSelector,
+            Func1> rightDurationSelector,
+            Func2 resultSelector) {
+        return create(new OperationJoin(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
     }
 
     /**
-     * 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.
-     * 
    
-     * 
+     * Returns an Observable that emits the last item emitted by the source or
+     * notifies observers of an IllegalArgumentException if the
+     * source Observable is empty.
      * 
    
-     * This technique, which is called "reduce" here, is sometimes called
-     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
-     * programming contexts. Groovy, for instance, has an inject
-     * method that does a similar operation on lists.
+     * 
      * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if the source Observable emits no items
-     * @see RxJava Wiki: reduce()
-     * @see MSDN: Observable.Aggregate
-     * @see Wikipedia: Fold (higher-order function)
+     * @return an Observable that emits the last item from the source Observable
+     *         or notifies observers of an error
+     * @see RxJava Wiki: last()
+     * @see MSDN: Observable.lastAsync()
      */
-    public Observable reduce(Func2 accumulator) {
-        /*
-         * Discussion and confirmation of implementation at https://github.com/Netflix/RxJava/issues/423#issuecomment-27642532
-         * 
-         * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
-         */
-        return create(OperationScan.scan(this, accumulator)).last();
+    public Observable last() {
+        return takeLast(1).single();
     }
 
     /**
-     * Returns an Observable emits the count of the total number of items
-     * emitted by the source Observable.
+     * Returns an Observable that emits only the last item emitted by the source
+     * Observable that satisfies a given condition, or an
+     * IllegalArgumentException if no such items are emitted.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits the number of elements emitted by the
-     *         source Observable as its single item
-     * @see RxJava Wiki: count()
-     * @see MSDN: Observable.Count
-     * @see #longCount()
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
+     * @return an Observable that emits only the last item satisfying the given
+     *         condition from the source, or an IllegalArgumentException if no
+     *         such items are emitted
+     * @throws IllegalArgumentException
+     *             if no such itmes are emmited
+     * @see RxJava Wiki: last()
+     * @see MSDN: Observable.lastAsync()
      */
-    public Observable count() {
-        return reduce(0, new Func2() {
-            @Override
-            public Integer call(Integer t1, T t2) {
-                return t1 + 1;
-            }
-        });
+    public Observable last(Func1 predicate) {
+        return filter(predicate).takeLast(1).single();
     }
 
     /**
-     * Returns an Observable that emits the sum of all the Integers emitted by
-     * the source Observable.
+     * Returns an Observable that emits only the last item emitted by the source
+     * Observable, or a default item if the source is empty.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the sum of
-     * @return an Observable that emits the sum of all the Integers emitted by
-     *         the source Observable as its single item
-     * @see RxJava Wiki: sumInteger()
-     * @see MSDN: Observable.Sum
+     * @param defaultValue
+     *            the default item to emit if the source Observable is
+     *            empty
+     * @return an Observable that emits only the last item from the source, or a
+     *         default item if the source is empty
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.lastOrDefaultAsync()
      */
-    public static Observable sumInteger(Observable source) {
-        return OperationSum.sum(source);
-    }
-
-    @Deprecated
-    public static Observable sum(Observable source) {
-        return OperationSum.sum(source);
+    public Observable lastOrDefault(T defaultValue) {
+        return takeLast(1).singleOrDefault(defaultValue);
     }
 
     /**
-     * Returns an Observable that emits the sum of all the Longs emitted by the
-     * source Observable.
+     * Returns an Observable that emits only the last item emitted by the source
+     * Observable that satisfies a given condition, or a default item otherwise.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the sum of
-     * @return an Observable that emits the sum of all the Longs emitted by the
-     *         source Observable as its single item
-     * @see RxJava Wiki: sumLong()
-     * @see MSDN: Observable.Sum
+     * @param defaultValue
+     *            the default item to emit if the source Observable
+     *            doesn't emit anything that satisfies the given
+     *            condition
+     * @param predicate
+     *            the condition any source emitted item has to satisfy
+     * @return an Observable that emits only the last item from the source that
+     *         satisfies the given condition, or a default item otherwise
+     * @see RxJava Wiki: lastOrDefault()
+     * @see MSDN: Observable.lastOrDefaultAsync()
      */
-    public static Observable sumLong(Observable source) {
-        return OperationSum.sumLongs(source);
+    public Observable lastOrDefault(T defaultValue, Func1 predicate) {
+        return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
     }
 
     /**
-     * Returns an Observable that emits the sum of all the Floats emitted by the
-     * source Observable.
+     * Returns an Observable that counts the total number of items emitted by
+     * the source Observable and emits this count as a 64-bit long.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the sum of
-     * @return an Observable that emits the sum of all the Floats emitted by the
-     *         source Observable as its single item
-     * @see RxJava Wiki: sumFloat()
-     * @see MSDN: Observable.Sum
+     * @return an Observable that emits the number of items emitted by the
+     *         source Observable as its single, 64-bit long item
+     * @see RxJava Wiki: count()
+     * @see MSDN: Observable.LongCount
+     * @see #count()
      */
-    public static Observable sumFloat(Observable source) {
-        return OperationSum.sumFloats(source);
+    public Observable longCount() {
+        return reduce(0L, new Func2() {
+            @Override
+            public Long call(Long t1, T t2) {
+                return t1 + 1;
+            }
+        });
     }
 
     /**
-     * Returns an Observable that emits the sum of all the Doubles emitted by
-     * the source Observable.
+     * Returns an Observable that applies the given function to each item
+     * emitted by an Observable and emits the results of these function
+     * applications.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the sum of
-     * @return an Observable that emits the sum of all the Doubles emitted by
-     *         the source Observable as its single item
-     * @see RxJava Wiki: sumDouble()
-     * @see MSDN: Observable.Sum
+     * @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
+     * @see RxJava Wiki: map()
+     * @see MSDN: Observable.Select
      */
-    public static Observable sumDouble(Observable source) {
-        return OperationSum.sumDoubles(source);
+    public  Observable map(Func1 func) {
+        return create(OperationMap.map(this, func));
     }
 
     /**
-     * Create an Observable that extracts an integer from each of the items
-     * emitted by the source Observable via a function you specify, and then
-     * emits the sum of these integers.
+     * 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 valueExtractor
-     *            the function to extract an integer from each item
-     *            emitted by the source Observable
-     * @return an Observable that emits the integer sum of the integer values
-     *         corresponding to the items emitted by the source Observable
-     *         transformed by the provided function
-     * @see RxJava Wiki: sumInteger()
-     * @see MSDN: Observable.Sum
+     * @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 RxJava Wiki: mapMany()
+     * @see #flatMap(Func1)
+     * @deprecated
      */
-    public Observable sumInteger(Func1 valueExtractor) {
-        return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
+    @Deprecated
+    public  Observable mapMany(Func1> func) {
+        return mergeMap(func);
     }
 
     /**
-     * Create an Observable that extracts a long from each of the items emitted
-     * by the source Observable via a function you specify, and then emits the
-     * sum of these longs.
+     * Returns an Observable that applies the given function to each item
+     * emitted by an Observable and emits the results of these function
+     * applications.
      * 
    
-     * 
+     * 
      * 
-     * @param valueExtractor
-     *            the function to extract a long from each item
-     *            emitted by the source Observable
-     * @return an Observable that emits the long sum of the integer values
-     *         corresponding to the items emitted by the source Observable
-     *         transformed by the provided function
-     * @see RxJava Wiki: sumLong()
-     * @see MSDN: Observable.Sum
+     * @param func
+     *            a function to apply to each item emitted by the Observable
+     *            that takes the index of the emitted item as additional
+     *            parameter
+     * @return an Observable that emits the items from the source Observable,
+     *         transformed by the given function
+     * @see RxJava Wiki: mapWithIndex()
+     * @see MSDN: Observable.Select
+     * @deprecated just use zip with {@link Observable#range(int)}
      */
-    public Observable sumLong(Func1 valueExtractor) {
-        return create(new OperationSum.SumLongExtractor(this, valueExtractor));
+    @Deprecated
+    public  Observable mapWithIndex(Func2 func) {
+        return create(OperationMap.mapWithIndex(this, func));
     }
 
     /**
-     * Create an Observable that extracts a float from each of the items emitted
-     * by the source Observable via a function you specify, and then emits the
-     * sum of these floats.
+     * Turns all of the emissions and notifications from a source Observable
+     * into emissions marked with their original types within {@link Notification} objects.
      * 
    
-     * 
+     * 
      * 
-     * @param valueExtractor
-     *            the function to extract a float from each item
-     *            emitted by the source Observable
-     * @return an Observable that emits the float sum of the integer values
-     *         corresponding to the items emitted by the source Observable
-     *         transformed by the provided function
-     * @see RxJava Wiki: sumFloat()
-     * @see MSDN: Observable.Sum
+     * @return an Observable whose items are the result of materializing the
+     *         items and notifications of the source Observable
+     * @see RxJava Wiki: materialize()
+     * @see MSDN: Observable.materialize
      */
-    public Observable sumFloat(Func1 valueExtractor) {
-        return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
+    public Observable> materialize() {
+        return create(OperationMaterialize.materialize(this));
     }
 
     /**
-     * Create an Observable that extracts a double from each of the items
-     * emitted by the source Observable via a function you specify, and then
-     * emits the sum of these doubles.
+     * Returns an Observable that emits the maximum item emitted by the source
+     * Observable, according to the specified comparator. If there is more than
+     * one item with the same maximum value, it emits the last-emitted of these.
      * 
    
-     * 
+     * 
      * 
-     * @param valueExtractor
-     *            the function to extract a double from each item
-     *            emitted by the source Observable
-     * @return an Observable that emits the double sum of the integer values
-     *         corresponding to the items emitted by the source Observable
-     *         transformed by the provided function
-     * @see RxJava Wiki: sumDouble()
-     * @see MSDN: Observable.Sum
+     * @param comparator
+     *            the comparer used to compare items
+     * @return an Observable that emits the maximum item emitted by the source
+     *         Observable, according to the specified comparator
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see RxJava Wiki: max()
+     * @see MSDN: Observable.Max
      */
-    public Observable sumDouble(Func1 valueExtractor) {
-        return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
+    public Observable max(Comparator comparator) {
+        return OperationMinMax.max(this, comparator);
     }
 
     /**
-     * Returns an Observable that computes the average of the Integers emitted
-     * by the source Observable.
+     * Returns an Observable that emits a List of items emitted by the source
+     * Observable that have the maximum key value. For a source Observable that
+     * emits no items, the resulting Observable emits an empty List.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source observable to compute the average of
-     * @return an Observable that emits the average of all the Integers emitted
-     *         by the source Observable as its single item
-     * @throws IllegalArgumentException
-     *             if the source Observable emits no items
-     * @see RxJava Wiki: averageInteger()
-     * @see MSDN: Observable.Average
+     * @param selector
+     *            the key selector function
+     * @return an Observable that emits a List of those items emitted by the
+     *         source Observable that had the maximum key value
+     * @see RxJava Wiki: maxBy()
+     * @see MSDN: Observable.MaxBy
      */
-    public static Observable averageInteger(Observable source) {
-        return OperationAverage.average(source);
-    }
-
-    @Deprecated
-    public static Observable average(Observable source) {
-        return OperationAverage.average(source);
+    public > Observable> maxBy(Func1 selector) {
+        return OperationMinMax.maxBy(this, selector);
     }
 
     /**
-     * Returns an Observable that computes the average of the Longs emitted by
-     * the source Observable.
+     * Returns an Observable that emits a List of items emitted by the source
+     * Observable that have the maximum key value according to a specified
+     * comparator. For a source Observable that emits no items, the resulting
+     * Observable emits an empty List.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the average of
-     * @return an Observable that emits the average of all the Longs emitted by
-     *         the source Observable as its single item
-     * @see RxJava Wiki: averageLong()
-     * @see MSDN: Observable.Average
+     * @param selector
+     *            the key selector function
+     * @param comparator
+     *            the comparator used to compare key values
+     * @return an Observable that emits a List of those items emitted by the
+     *         source Observable that had the maximum key value according to the
+     *         specified comparator
+     * @see RxJava Wiki: maxBy()
+     * @see MSDN: Observable.MaxBy
      */
-    public static Observable averageLong(Observable source) {
-        return OperationAverage.averageLongs(source);
+    public  Observable> maxBy(Func1 selector, Comparator comparator) {
+        return OperationMinMax.maxBy(this, selector, comparator);
     }
 
     /**
-     * Returns an Observable that computes the average of the Floats emitted by
-     * the source Observable.
+     * 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.
      * 
    
-     * 
+     * 
      * 
-     * @param source
-     *            source Observable to compute the average of
-     * @return an Observable that emits the average of all the Floats emitted by
-     *         the source Observable as its single item
-     * @see RxJava Wiki: averageFloat()
-     * @see MSDN: Observable.Average
+     * @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 RxJava Wiki: flatMap()
+     * @see #flatMap(Func1)
      */
-    public static Observable averageFloat(Observable source) {
-        return OperationAverage.averageFloats(source);
+    public  Observable mergeMap(Func1> func) {
+        return merge(map(func));
     }
 
     /**
-     * Returns an Observable that emits the average of the Doubles emitted
-     * by the source Observable.
-     * 
    
-     * 
+     * Create an Observable that projects the notification of an observable sequence to an observable
+     * sequence and merges the results into one.
      * 
-     * @param source
-     *            source Observable to compute the average of
-     * @return an Observable that emits the average of all the Doubles emitted
-     *         by the source Observable as its single item
-     * @see RxJava Wiki: averageDouble()
-     * @see MSDN: Observable.Average
-     */
-    public static Observable averageDouble(Observable source) {
-        return OperationAverage.averageDoubles(source);
-    }
-
-    /**
-     * Create an Observable that transforms items emitted by the source
-     * Observable into integers by using a function you provide and then emits
-     * the integer average of the complete sequence of transformed values.
-     * 
    
-     * 
-     * 
-     * @param valueExtractor
-     *            the function to transform an item emitted by the
-     *            source Observable into an integer
-     * @return an Observable that emits the integer average of the complete
-     *         sequence of items emitted by the source Observable when
-     *         transformed into integers by the specified function
-     * @see RxJava Wiki: averageInteger()
-     * @see MSDN: Observable.Average
-     */
-    public Observable averageInteger(Func1 valueExtractor) {
-        return create(new OperationAverage.AverageIntegerExtractor(this, valueExtractor));
-    }
-
-    /**
-     * Create an Observable that transforms items emitted by the source
-     * Observable into longs by using a function you provide and then emits
-     * the long average of the complete sequence of transformed values.
-     * 
    
-     * 
-     * 
-     * @param valueExtractor
-     *            the function to transform an item emitted by the
-     *            source Observable into a long
-     * @return an Observable that emits the long average of the complete
-     *         sequence of items emitted by the source Observable when
-     *         transformed into longs by the specified function
-     * @see RxJava Wiki: averageLong()
-     * @see MSDN: Observable.Average
+     * @param 
+     *            the result type
+     * @param onNext
+     *            function returning a collection to merge for each onNext event of the source
+     * @param onError
+     *            function returning a collection to merge for an onError event
+     * @param onCompleted
+     *            function returning a collection to merge for an onCompleted event
+     * @return an Observable that projects the notification of an observable sequence to an observable
+     *         sequence and merges the results into one.
      */
-    public Observable averageLong(Func1 valueExtractor) {
-        return create(new OperationAverage.AverageLongExtractor(this, valueExtractor));
+    public  Observable mergeMap(
+            Func1> onNext,
+            Func1> onError,
+            Func0> onCompleted) {
+        return create(OperationFlatMap.flatMap(this, onNext, onError, onCompleted));
     }
 
     /**
-     * Create an Observable that transforms items emitted by the source
-     * Observable into floats by using a function you provide and then emits
-     * the float average of the complete sequence of transformed values.
-     * 
    
-     * 
+     * Create an Observable that applies a function to the pair of values from the source
+     * Observable and the collection Observable.
      * 
-     * @param valueExtractor
-     *            the function to transform an item emitted by the
-     *            source Observable into a float
-     * @return an Observable that emits the float average of the complete
-     *         sequence of items emitted by the source Observable when
-     *         transformed into floats by the specified function
-     * @see RxJava Wiki: averageFloat()
-     * @see MSDN: Observable.Average
+     * @param 
+     *            the element type of the collection Observable
+     * @param 
+     *            the result type
+     * @param collectionSelector
+     *            function that returns an Observable sequence for each value in the source Observable
+     * @param resultSelector
+     *            function that combines the values of the source and collection Observable
+     * @return an Observable that applies a function to the pair of values from the source
+     *         Observable and the collection Observable.
      */
-    public Observable averageFloat(Func1 valueExtractor) {
-        return create(new OperationAverage.AverageFloatExtractor(this, valueExtractor));
+    public  Observable mergeMap(Func1> collectionSelector,
+            Func2 resultSelector) {
+        return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
     }
 
     /**
-     * Create an Observable that transforms items emitted by the source
-     * Observable into doubles by using a function you provide and then emits
-     * the double average of the complete sequence of transformed values.
-     * 
    
-     * 
+     * Create an Observable that merges the values of the iterables returned by the
+     * collectionSelector for each source value.
      * 
-     * @param valueExtractor
-     *            the function to transform an item emitted by the
-     *            source Observable into a double
-     * @return an Observable that emits the double average of the complete
-     *         sequence of items emitted by the source Observable when
-     *         transformed into doubles by the specified function
-     * @see RxJava Wiki: averageDouble()
-     * @see MSDN: Observable.Average
+     * @param 
+     *            the result value type
+     * @param collectionSelector
+     *            function that returns an Iterable sequence of values for
+     *            each source value.
+     * @return an Observable that merges the values of the iterables returned by the
+     *         collectionSelector for each source value.
      */
-    public Observable averageDouble(Func1 valueExtractor) {
-        return create(new OperationAverage.AverageDoubleExtractor(this, valueExtractor));
+    public  Observable mergeMapIterable(Func1> collectionSelector) {
+        return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
     }
 
     /**
-     * Returns an Observable that emits the minimum item emitted by the source
-     * Observable. If there is more than one such item, it returns the
-     * last-emitted one.
-     * 
    
-     * 
+     * Create an Observable that applies a function to the pair of values from the source
+     * Observable and the collection Iterable sequence.
      * 
-     * @param source
-     *            an Observable to determine the minimum item of
-     * @return an Observable that emits the minimum item emitted by the source
-     *         Observable
-     * @throws IllegalArgumentException
-     *             if the source is empty
-     * @see MSDN: Observable.Min
+     * @param 
+     *            the collection element type
+     * @param 
+     *            the result type
+     * @param collectionSelector
+     *            function that returns an Iterable sequence of values for
+     *            each source value.
+     * @param resultSelector
+     *            function that combines the values of the source and collection Iterable
+     * @return n Observable that applies a function to the pair of values from the source
+     *         Observable and the collection Iterable sequence.
      */
-    public static > Observable min(Observable source) {
-        return OperationMinMax.min(source);
+    public  Observable mergeMapIterable(Func1> collectionSelector,
+            Func2 resultSelector) {
+        return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
     }
 
     /**
@@ -5375,313 +5329,493 @@ public  Observable> minBy(Func1 selector, Comparator
     }
 
     /**
-     * Returns an Observable that emits the maximum item emitted by the source
-     * Observable. If there is more than one item with the same maximum value,
-     * it emits the last-emitted of these.
-     * 
    
-     * 
+     * Returns an observable sequence that contains the elements of a sequence
+     * produced by multicasting the source sequence within a selector function.
      * 
-     * @param source
-     *            an Observable to scan for the maximum emitted item
-     * @return an Observable that emits this maximum item from the source
-     * @throws IllegalArgumentException
-     *             if the source is empty
-     * @see RxJava Wiki: max()
-     * @see MSDN: Observable.Max
+     * @param subjectFactory
+     *            the subject factory
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            source sequence subject to the policies enforced by the
+     *            created subject
+     * @return the Observable sequence that contains the elements of a sequence
+     *         produced by multicasting the source sequence within a selector
+     *         function
+     * @see RxJava: Observable.publish() and Observable.multicast()
+     * @see MSDN: Observable.Multicast
      */
-    public static > Observable max(Observable source) {
-        return OperationMinMax.max(source);
+    public  Observable multicast(
+            final Func0> subjectFactory,
+            final Func1, ? extends Observable> selector) {
+        return OperationMulticast.multicast(this, subjectFactory, selector);
     }
 
     /**
-     * Returns an Observable that emits the maximum item emitted by the source
-     * Observable, according to the specified comparator. If there is more than
-     * one item with the same maximum value, it emits the last-emitted of these.
-     * 
    
-     * 
+     * Returns a {@link ConnectableObservable} that upon connection causes the
+     * source Observable to push results into the specified subject.
      * 
-     * @param comparator
-     *            the comparer used to compare items
-     * @return an Observable that emits the maximum item emitted by the source
-     *         Observable, according to the specified comparator
-     * @throws IllegalArgumentException
-     *             if the source is empty
-     * @see RxJava Wiki: max()
-     * @see MSDN: Observable.Max
+     * @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}
+     * @see RxJava Wiki: Observable.publish() and Observable.multicast()
      */
-    public Observable max(Comparator comparator) {
-        return OperationMinMax.max(this, comparator);
+    public  ConnectableObservable multicast(Subject subject) {
+        return OperationMulticast.multicast(this, subject);
     }
 
     /**
-     * Returns an Observable that emits a List of items emitted by the source
-     * Observable that have the maximum key value. For a source Observable that
-     * emits no items, the resulting Observable emits an empty List.
+     * Asynchronously notify {@link Observer}s on the specified {@link Scheduler}.
      * 
    
-     * 
+     * 
      * 
-     * @param selector
-     *            the key selector function
-     * @return an Observable that emits a List of those items emitted by the
-     *         source Observable that had the maximum key value
-     * @see RxJava Wiki: maxBy()
-     * @see MSDN: Observable.MaxBy
+     * @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}
+     * @see RxJava Wiki: observeOn()
      */
-    public > Observable> maxBy(Func1 selector) {
-        return OperationMinMax.maxBy(this, selector);
+    public Observable observeOn(Scheduler scheduler) {
+        return create(OperationObserveOn.observeOn(this, scheduler));
     }
 
     /**
-     * Returns an Observable that emits a List of items emitted by the source
-     * Observable that have the maximum key value according to a specified
-     * comparator. For a source Observable that emits no items, the resulting
-     * Observable emits an empty List.
+     * Filters the items emitted by an Observable based on the specified type.
      * 
    
-     * 
+     * 
      * 
-     * @param selector
-     *            the key selector function
-     * @param comparator
-     *            the comparator used to compare key values
-     * @return an Observable that emits a List of those items emitted by the
-     *         source Observable that had the maximum key value according to the
-     *         specified comparator
-     * @see RxJava Wiki: maxBy()
-     * @see MSDN: Observable.MaxBy
+     * @param klass
+     *            the class type to filter the items emitted by the source
+     *            Observable
+     * @return an Observable that emits items from the source Observable of
+     *         type klass.
+     * @see RxJava Wiki: ofType()
+     * @see MSDN: Observable.OfType
      */
-    public  Observable> maxBy(Func1 selector, Comparator comparator) {
-        return OperationMinMax.maxBy(this, selector, comparator);
+    public  Observable ofType(final Class klass) {
+        return filter(new Func1() {
+            public Boolean call(T t) {
+                return klass.isInstance(t);
+            }
+        }).cast(klass);
     }
 
     /**
-     * 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}.
+     * 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.
      * 
-     * @return a {@link ConnectableObservable} that upon connection causes the
-     *         source Observable to emit items to its {@link Observer}s
-     * @see RxJava Wiki: replay()
+     * @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
+     * @see RxJava Wiki: onErrorResumeNext()
      */
-    public ConnectableObservable replay() {
-        return OperationMulticast.multicast(this, ReplaySubject. create());
+    public Observable onErrorResumeNext(final Func1> resumeFunction) {
+        return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
     }
 
     /**
-     * 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} on the given scheduler.
+     * 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 scheduler
-     *            the scheduler on which the Observers will observe the
-     *            emitted items
-     * @return a {@link ConnectableObservable} that shares a single subscription
-     *         to the source Observable that will replay all of its items and
-     *         notifications to any future {@link Observer} on the given
-     *         scheduler
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @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
+     * @see RxJava Wiki: onErrorResumeNext()
      */
-    public ConnectableObservable replay(Scheduler scheduler) {
-        return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler));
+    public Observable onErrorResumeNext(final Observable resumeSequence) {
+        return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the source Observable that replays at most {@code bufferSize} items emitted by that Observable.
+     * 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 emit the return value of resumeFunction.
+     * 
    
+     * You can use this to prevent errors from propagating or to supply fallback
+     * data should errors be encountered.
      * 
-     * @param bufferSize
-     *            the buffer size
-     * @return a connectable observable sequence that shares a single
-     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @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
+     * @see RxJava Wiki: onErrorReturn()
      */
-    public ConnectableObservable replay(int bufferSize) {
-        return OperationMulticast.multicast(this, OperationReplay. replayBuffered(bufferSize));
+    public Observable onErrorReturn(Func1 resumeFunction) {
+        return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable.
+     * 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 bufferSize
-     *            the buffer size
-     * @param scheduler
-     *            the scheduler on which the Observers will observe the
-     *            emitted items
-     * @return a connectable observable sequence that shares a single
-     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @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
+     * @see RxJava Wiki: onExceptionResumeNextViaObservable()
      */
-    public ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
-        return OperationMulticast.multicast(this,
-                OperationReplay.createScheduledSubject(
-                        OperationReplay. replayBuffered(bufferSize), scheduler));
+    public Observable onExceptionResumeNext(final Observable resumeSequence) {
+        return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the source Observable and replays all items emitted by
-     * that Observable within a time window.
+     * Perform work in parallel by sharding an {@code Observable} on a {@link Schedulers#threadPoolForComputation()} {@link Scheduler} and
+     * return an {@code Observable} with the output.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the window length
-     * @param unit
-     *            the window length time unit
-     * @return a connectable observable sequence that shares a single
-     *         subscription to the source Observable and that replays all items
-     *         emitted by that Observable during the window defined by {@code time} and {@code unit}
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @param f
+     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
+     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
+     * @see RxJava Wiki: parallel()
      */
-    public ConnectableObservable replay(long time, TimeUnit unit) {
-        return replay(time, unit, Schedulers.threadPoolForComputation());
+    public  Observable parallel(Func1, Observable> f) {
+        return OperationParallel.parallel(this, f);
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the source Observable and replays all items emitted by
-     * that Observable within a time window.
+     * Perform work in parallel by sharding an {@code Observable} on a {@link Scheduler} and return an {@code Observable} with the output.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the window length
-     * @param unit
-     *            the window length time unit
-     * @param scheduler
-     *            the scheduler that is used as a time source for the
-     *            window
-     * @return a connectable observable sequence that shares a single
-     *         subscription to the source Observable and replays all items
-     *         emitted by that Observable within the window defined by {@code time} and {@code unit}
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @param f
+     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
+     * @param s
+     *            a {@link Scheduler} to perform the work on
+     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
+     * @see RxJava Wiki: parallel()
      */
-    public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) {
-        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, -1, scheduler));
+    public  Observable parallel(final Func1, Observable> f, final Scheduler s) {
+        return OperationParallel.parallel(this, f, s);
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
+     * Protects against errors being thrown from Observer implementations and
+     * ensures onNext/onError/onCompleted contract compliance.
      * 
    
-     * 
-     * 
-     * @param bufferSize
-     *            the buffer size
-     * @param time
-     *            the window length
-     * @param unit
-     *            the window length time unit
-     * @return Returns a connectable observable sequence that shares a single
-     *         subscription to the underlying sequence replaying bufferSize notifications within window
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * See https://github.com/Netflix/RxJava/issues/216 for a discussion on
+     * "Guideline 6.4: Protect calls to user code from within an operator"
      */
-    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) {
-        return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation());
+    private Subscription protectivelyWrapAndSubscribe(Observer o) {
+        SafeObservableSubscription subscription = new SafeObservableSubscription();
+        return subscription.wrap(subscribe(new SafeObserver(subscription, o)));
     }
 
     /**
-     * Returns a connectable observable sequence that shares a single
-     * subscription to the underlying sequence and that replays a maximum of {@code bufferSize} items that are emitted within the window defined by {@code time} and {@code unit}.
+     * 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.
      * 
    
-     * 
+     * 
      * 
-     * @param bufferSize
-     *            the buffer size
-     * @param time
-     *            the window length
-     * @param unit
-     *            the window length time unit
-     * @param scheduler
-     *            the scheduler that is used as a time source for the
-     *            window
-     * @return a connectable observable sequence that shares a single
-     *         subscription to the underlying sequence that replays a maximum of {@code bufferSize} items that are emitted within the window
-     *         defined by {@code time} and {@code unit}
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @return a {@link ConnectableObservable} that upon connection causes the
+     *         source Observable to emit items to its {@link Observer}s
+     * @see RxJava Wiki: publish()
      */
-    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
-        if (bufferSize < 0) {
-            throw new IllegalArgumentException("bufferSize < 0");
-        }
-        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, bufferSize, scheduler));
+    public ConnectableObservable publish() {
+        return OperationMulticast.multicast(this, PublishSubject. create());
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the
+     * Create an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence and starts with initial value.
+     * subscription to the underlying sequence.
      * 
      * @param 
-     *            the return element type
+     *            the result type
      * @param selector
-     *            the selector function which can use the multicasted
-     *            this sequence as many times as needed, without causing
-     *            multiple subscriptions to this sequence
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will receive all notifications of the source from the time
+     *            of the subscription on.
      * @return an observable sequence that is the result of invoking the
-     *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence and starts with
-     *         initial value
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     *         selector on a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence.
      */
-    public  Observable replay(Func1, ? extends Observable> selector) {
-        return OperationMulticast.multicast(this, new Func0>() {
+    public  Observable publish(Func1, ? extends Observable> selector) {
+        return multicast(new Func0>() {
             @Override
             public Subject call() {
-                return ReplaySubject.create();
+                return PublishSubject.create();
             }
         }, selector);
     }
 
     /**
-     * Returns an observable sequence that is the result of invoking the
+     * Create an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
+     * initialValue.
+     * 
+     * @param 
+     *            the result type
+     * @param selector
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will receive all notifications of the source from the time
+     *            of the subscription on
+     * @param initialValue
+     *            the initial value of the underlying BehaviorSubject
+     * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
+     *         initialValue
+     */
+    public  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
+        return multicast(new Func0>() {
+            @Override
+            public Subject call() {
+                return BehaviorSubject.create(initialValue);
+            }
+        }, selector);
+    }
+
+    /**
+     * Create a connectable observable sequence that shares a single
+     * subscription to the underlying sequence and starts with initialValue.
+     * 
+     * @param initialValue
+     *            the initial value of the underlying BehaviorSubject
+     * @return a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
+     */
+    public ConnectableObservable publish(T initialValue) {
+        return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
+    }
+
+    /**
+     * Returns a {@link ConnectableObservable} that emits only the last item
+     * emitted by the source Observable.
+     * 
    
+     * 
+     * 
+     * @return a {@link ConnectableObservable}
+     * @see RxJava Wiki: publishLast()
+     */
+    public ConnectableObservable publishLast() {
+        return OperationMulticast.multicast(this, AsyncSubject. create());
+    }
+
+    /**
+     * Create an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying all notifications.
+     * subscription to the underlying sequence containing only the last
+     * notification.
      * 
      * @param 
-     *            the return element type
+     *            the result type
      * @param selector
-     *            the selector function which can use the multicasted
-     *            this sequence as many times as needed, without causing
-     *            multiple subscriptions to this sequence
-     * @param scheduler
-     *            the scheduler where the replay is observed
+     *            function which can use the multicasted source
+     *            sequence as many times as needed, without causing multiple
+     *            subscriptions to the source sequence. Subscribers to the given
+     *            source will only receive the last notification of the source
      * @return an observable sequence that is the result of invoking the
-     *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying all
-     *         notifications
-     * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     *         selector on a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence containing only the last
+     *         notification.
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) {
-        return OperationMulticast.multicast(this, new Func0>() {
+    public  Observable publishLast(Func1, ? extends Observable> selector) {
+        return multicast(new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler);
+                return AsyncSubject.create();
             }
         }, selector);
     }
 
+    /**
+     * 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" here, is sometimes called
+     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
+     * programming contexts. Groovy, for instance, has an inject
+     * method that does a similar operation on lists.
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
+     * @see RxJava Wiki: reduce()
+     * @see MSDN: Observable.Aggregate
+     * @see Wikipedia: Fold (higher-order function)
+     */
+    public Observable reduce(Func2 accumulator) {
+        /*
+         * Discussion and confirmation of implementation at https://github.com/Netflix/RxJava/issues/423#issuecomment-27642532
+         * 
+         * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
+         */
+        return create(OperationScan.scan(this, accumulator)).last();
+    }
+
+    /**
+     * 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" here, is sometimec called
+     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
+     * programming contexts. Groovy, for instance, has an inject
+     * method that does a similar operation on lists.
+     * 
+     * @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 RxJava Wiki: reduce()
+     * @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);
+    }
+
+    /**
+     * Repeats the observable sequence indefinitely.
+     * 
    
+     * 
+     * 
+     * @return an Observable that emits the items emitted by the source
+     *         Observable repeatedly and in sequence
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
+     */
+    public Observable repeat() {
+        return this.repeat(Schedulers.currentThread());
+    }
+
+    /**
+     * Repeats the observable sequence indefinitely, on a particular scheduler.
+     * 
    
+     * 
+     * 
+     * @param scheduler
+     *            the scheduler to send the values on.
+     * @return an Observable that emits the items emitted by the source
+     *         Observable repeatedly and in sequence
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
+     */
+    public Observable repeat(Scheduler scheduler) {
+        return create(OperationRepeat.repeat(this, scheduler));
+    }
+
+    /**
+     * 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
+     * @see RxJava Wiki: replay()
+     */
+    public ConnectableObservable replay() {
+        return OperationMulticast.multicast(this, ReplaySubject. create());
+    }
+
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying {@code bufferSize} notifications.
+     * subscription to the underlying sequence and starts with initial value.
      * 
      * @param 
      *            the return element type
@@ -5689,19 +5823,18 @@ public Subject call() {
      *            the selector function which can use the multicasted
      *            this sequence as many times as needed, without causing
      *            multiple subscriptions to this sequence
-     * @param bufferSize
-     *            the buffer size
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications
+     *         single subscription to the underlying sequence and starts with
+     *         initial value
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize) {
+    public  Observable replay(Func1, ? extends Observable> selector) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.replayBuffered(bufferSize);
+                return ReplaySubject.create();
             }
         }, selector);
     }
@@ -5719,19 +5852,17 @@ public Subject call() {
      *            multiple subscriptions to this sequence
      * @param bufferSize
      *            the buffer size
-     * @param scheduler
-     *            the scheduler where the replay is observed
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
      *         single subscription to the underlying sequence replaying {@code bufferSize} notifications
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) {
+    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay. createScheduledSubject(OperationReplay. replayBuffered(bufferSize), scheduler);
+                return OperationReplay.replayBuffered(bufferSize);
             }
         }, selector);
     }
@@ -5739,8 +5870,7 @@ public Subject call() {
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying all notifications
-     * within window.
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
      * 
      * @param 
      *            the return element type
@@ -5748,26 +5878,26 @@ public Subject call() {
      *            the selector function which can use the multicasted
      *            this sequence as many times as needed, without causing
      *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
      * @param time
      *            the window length
      * @param unit
      *            the window length time unit
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying all
-     *         notifications within window
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) {
-        return replay(selector, time, unit, Schedulers.threadPoolForComputation());
+    public  Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) {
+        return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying all notifications
-     * within window.
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
      * 
      * @param 
      *            the return element type
@@ -5775,25 +5905,29 @@ public  Observable replay(Func1, ? extends Observabl
      *            the selector function which can use the multicasted
      *            this sequence as many times as needed, without causing
      *            multiple subscriptions to this sequence
+     * @param bufferSize
+     *            the buffer size
      * @param time
      *            the window length
      * @param unit
      *            the window length time unit
      * @param scheduler
-     *            the scheduler that is used as a time source for the
+     *            the scheduler which is used as a time source for the
      *            window
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying all
-     *         notifications within window
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
+    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
+        if (bufferSize < 0) {
+            throw new IllegalArgumentException("bufferSize < 0");
+        }
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.replayWindowed(time, unit, -1, scheduler);
+                return OperationReplay.replayWindowed(time, unit, bufferSize, scheduler);
             }
         }, selector);
     }
@@ -5801,7 +5935,7 @@ public Subject call() {
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications.
      * 
      * @param 
      *            the return element type
@@ -5811,24 +5945,55 @@ public Subject call() {
      *            multiple subscriptions to this sequence
      * @param bufferSize
      *            the buffer size
+     * @param scheduler
+     *            the scheduler where the replay is observed
+     * @return an observable sequence that is the result of invoking the
+     *         selector on a connectable observable sequence that shares a
+     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
+     */
+    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) {
+        return OperationMulticast.multicast(this, new Func0>() {
+            @Override
+            public Subject call() {
+                return OperationReplay. createScheduledSubject(OperationReplay. replayBuffered(bufferSize), scheduler);
+            }
+        }, selector);
+    }
+
+    /**
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying all notifications
+     * within window.
+     * 
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
      * @param time
      *            the window length
      * @param unit
      *            the window length time unit
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
+     *         single subscription to the underlying sequence replaying all
+     *         notifications within window
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) {
-        return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation());
+    public  Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) {
+        return replay(selector, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
      * Returns an observable sequence that is the result of invoking the
      * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
+     * subscription to the underlying sequence replaying all notifications
+     * within window.
      * 
      * @param 
      *            the return element type
@@ -5836,394 +6001,315 @@ public  Observable replay(Func1, ? extends Observabl
      *            the selector function which can use the multicasted
      *            this sequence as many times as needed, without causing
      *            multiple subscriptions to this sequence
-     * @param bufferSize
-     *            the buffer size
      * @param time
      *            the window length
      * @param unit
      *            the window length time unit
      * @param scheduler
-     *            the scheduler which is used as a time source for the
+     *            the scheduler that is used as a time source for the
      *            window
      * @return an observable sequence that is the result of invoking the
      *         selector on a connectable observable sequence that shares a
-     *         single subscription to the underlying sequence replaying {@code bufferSize} notifications within window
+     *         single subscription to the underlying sequence replaying all
+     *         notifications within window
      * @see RxJava Wiki: replay()
-     * @see MSDN: Observable.Replay
+     * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
-        if (bufferSize < 0) {
-            throw new IllegalArgumentException("bufferSize < 0");
-        }
+    public  Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
             public Subject call() {
-                return OperationReplay.replayWindowed(time, unit, bufferSize, scheduler);
+                return OperationReplay.replayWindowed(time, unit, -1, scheduler);
             }
         }, selector);
     }
 
     /**
-     * Retry subscription to the source Observable when it calls
-     * onError up to a certain number of retries.
-     * 
    
-     * 
-     * 
    
-     * If the source Observable calls {@link Observer#onError}, this method will
-     * resubscribe to the source Observable for a maximum of
-     * retryCount resubscriptions.
-     * 
    
-     * Any and all items emitted by the source Observable will be emitted by
-     * the resulting Observable, even those emitted during failed subscriptions.
-     * For example, if an Observable fails at first but emits [1, 2] then
-     * succeeds the second time and emits [1, 2, 3, 4, 5] then the complete
-     * sequence of emissions and notifications would be
-     * [1, 2, 1, 2, 3, 4, 5, onCompleted].
+     * Returns an observable sequence that is the result of invoking the
+     * selector on a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying all notifications.
      * 
-     * @param retryCount
-     *            number of retry attempts before failing
-     * @return the source Observable modified with retry logic
-     * @see RxJava Wiki: retry()
+     * @param 
+     *            the return element type
+     * @param selector
+     *            the selector function which can use the multicasted
+     *            this sequence as many times as needed, without causing
+     *            multiple subscriptions to this sequence
+     * @param scheduler
+     *            the scheduler where the replay is observed
+     * @return an observable sequence that is the result of invoking the
+     *         selector on a connectable observable sequence that shares a
+     *         single subscription to the underlying sequence replaying all
+     *         notifications
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public Observable retry(int retryCount) {
-        return create(OperationRetry.retry(this, retryCount));
+    public  Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) {
+        return OperationMulticast.multicast(this, new Func0>() {
+            @Override
+            public Subject call() {
+                return OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler);
+            }
+        }, selector);
     }
 
     /**
-     * Retry subscription to the source Observable whenever it calls
-     * onError (infinite retry count).
-     * 
    
-     * 
-     * 
    
-     * If the source Observable calls {@link Observer#onError}, this method will
-     * resubscribe to the source Observable.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the source Observable that replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
-     * Any and all items emitted by the source Observable will be emitted by
-     * the resulting Observable, even those emitted during failed subscriptions.
-     * For example, if an Observable fails at first but emits [1, 2] then
-     * succeeds the second time and emits [1, 2, 3, 4, 5] then the complete
-     * sequence of emissions and notifications would be
-     * [1, 2, 1, 2, 3, 4, 5, onCompleted].
+     * 
      * 
-     * @return the source Observable modified with retry logic
-     * @see RxJava Wiki: retry()
+     * @param bufferSize
+     *            the buffer size
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public Observable retry() {
-        return create(OperationRetry.retry(this));
+    public ConnectableObservable replay(int bufferSize) {
+        return OperationMulticast.multicast(this, OperationReplay. replayBuffered(bufferSize));
     }
 
     /**
-     * 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.
-     * 
    
-     * When you call {@code cache()}, it does not yet subscribe to the
-     * source Observable. This only happens when {@code subscribe} is called
-     * the first time on the Observable returned by {@code cache()}.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the underlying sequence replaying {@code bufferSize} notifications within window.
      * 
    
-     * 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
-     *         items and notifications for the benefit of subsequent observers
-     * @see RxJava Wiki: cache()
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @return Returns a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence replaying bufferSize notifications within window
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public Observable cache() {
-        return create(OperationCache.cache(this));
+    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) {
+        return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Perform work in parallel by sharding an {@code Observable} on a {@link Schedulers#threadPoolForComputation()} {@link Scheduler} and
-     * return an {@code Observable} with the output.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the underlying sequence and that replays a maximum of {@code bufferSize} items that are emitted within the window defined by {@code time} and {@code unit}.
      * 
    
-     * 
+     * 
      * 
-     * @param f
-     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
-     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
-     * @see RxJava Wiki: parallel()
+     * @param bufferSize
+     *            the buffer size
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @param scheduler
+     *            the scheduler that is used as a time source for the
+     *            window
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the underlying sequence that replays a maximum of {@code bufferSize} items that are emitted within the window
+     *         defined by {@code time} and {@code unit}
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public  Observable parallel(Func1, Observable> f) {
-        return OperationParallel.parallel(this, f);
+    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
+        if (bufferSize < 0) {
+            throw new IllegalArgumentException("bufferSize < 0");
+        }
+        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, bufferSize, scheduler));
     }
 
     /**
-     * Perform work in parallel by sharding an {@code Observable} on a {@link Scheduler} and return an {@code Observable} with the output.
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param f
-     *            a {@link Func1} that applies Observable operators to {@code Observable} in parallel and returns an {@code Observable}
-     * @param s
-     *            a {@link Scheduler} to perform the work on
-     * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
-     * @see RxJava Wiki: parallel()
+     * @param bufferSize
+     *            the buffer size
+     * @param scheduler
+     *            the scheduler on which the Observers will observe the
+     *            emitted items
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and replays at most {@code bufferSize} items emitted by that Observable
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public  Observable parallel(final Func1, Observable> f, final Scheduler s) {
-        return OperationParallel.parallel(this, f, s);
+    public ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
+        return OperationMulticast.multicast(this,
+                OperationReplay.createScheduledSubject(
+                        OperationReplay. replayBuffered(bufferSize), scheduler));
     }
 
     /**
-     * Merges an Observable<Observable<T>> to
-     * Observable<Observable<T>> with the number of
-     * inner Observables defined by parallelObservables.
-     * 
    
-     * For example, if the original
-     * Observable<Observable<T>> has 100 Observables to
-     * be emitted and parallelObservables is 8, the 100 will be
-     * grouped onto 8 output Observables.
-     * 
    
-     * This is a mechanism for efficiently processing n number of
-     * Observables on a smaller m number of resources (typically CPU
-     * cores).
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the source Observable and replays all items emitted by
+     * that Observable within a time window.
      * 
    
-     * 
+     * 
      * 
-     * @param parallelObservables
-     *            the number of Observables to merge into
-     * @return an Observable of Observables constrained in number by
-     *         parallelObservables
-     * @see RxJava Wiki: parallelMerge()
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and that replays all items
+     *         emitted by that Observable during the window defined by {@code time} and {@code unit}
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public static  Observable> parallelMerge(Observable> source, int parallelObservables) {
-        return OperationParallelMerge.parallelMerge(source, parallelObservables);
+    public ConnectableObservable replay(long time, TimeUnit unit) {
+        return replay(time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Merges an Observable<Observable<T>> to
-     * Observable<Observable<T>> with the number of
-     * inner Observables defined by parallelObservables and runs
-     * each Observable on the defined Scheduler.
-     * 
    
-     * For example, if the original
-     * Observable<Observable<T>> has 100 Observables to
-     * be emitted and parallelObservables is 8, the 100 will be
-     * grouped onto 8 output Observables.
-     * 
    
-     * This is a mechanism for efficiently processing n number of
-     * Observables on a smaller m number of resources (typically CPU
-     * cores).
+     * Returns a connectable observable sequence that shares a single
+     * subscription to the source Observable and replays all items emitted by
+     * that Observable within a time window.
      * 
    
-     * 
+     * 
      * 
-     * @param parallelObservables
-     *            the number of Observables to merge into
+     * @param time
+     *            the window length
+     * @param unit
+     *            the window length time unit
      * @param scheduler
-     *            the Scheduler to run each Observable on
-     * @return an Observable of Observables constrained in number by
-     *         parallelObservables
-     * @see RxJava Wiki: parallelMerge()
+     *            the scheduler that is used as a time source for the
+     *            window
+     * @return a connectable observable sequence that shares a single
+     *         subscription to the source Observable and replays all items
+     *         emitted by that Observable within the window defined by {@code time} and {@code unit}
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public static  Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) {
-        return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
+    public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) {
+        return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, -1, scheduler));
     }
 
     /**
-     * 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.
+     * 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} on the given scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @return a {@link ConnectableObservable} that upon connection causes the
-     *         source Observable to emit items to its {@link Observer}s
-     * @see RxJava Wiki: publish()
+     * @param scheduler
+     *            the scheduler on which the Observers will observe the
+     *            emitted items
+     * @return a {@link ConnectableObservable} that shares a single subscription
+     *         to the source Observable that will replay all of its items and
+     *         notifications to any future {@link Observer} on the given
+     *         scheduler
+     * @see RxJava Wiki: replay()
+     * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable publish() {
-        return OperationMulticast.multicast(this, PublishSubject. create());
+    public ConnectableObservable replay(Scheduler scheduler) {
+        return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler));
     }
 
     /**
-     * Create a connectable observable sequence that shares a single
-     * subscription to the underlying sequence and starts with initialValue.
+     * Retry subscription to the source Observable whenever it calls
+     * onError (infinite retry count).
+     * 
    
+     * 
+     * 
    
+     * If the source Observable calls {@link Observer#onError}, this method will
+     * resubscribe to the source Observable.
+     * 
    
+     * Any and all items emitted by the source Observable will be emitted by
+     * the resulting Observable, even those emitted during failed subscriptions.
+     * For example, if an Observable fails at first but emits [1, 2] then
+     * succeeds the second time and emits [1, 2, 3, 4, 5] then the complete
+     * sequence of emissions and notifications would be
+     * [1, 2, 1, 2, 3, 4, 5, onCompleted].
      * 
-     * @param initialValue
-     *            the initial value of the underlying BehaviorSubject
-     * @return a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
+     * @return the source Observable modified with retry logic
+     * @see RxJava Wiki: retry()
      */
-    public ConnectableObservable publish(T initialValue) {
-        return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
+    public Observable retry() {
+        return create(OperationRetry.retry(this));
     }
 
     /**
-     * Create an observable sequence that is the result of invoking the
-     * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence.
+     * Retry subscription to the source Observable when it calls
+     * onError up to a certain number of retries.
+     * 
    
+     * 
+     * 
    
+     * If the source Observable calls {@link Observer#onError}, this method will
+     * resubscribe to the source Observable for a maximum of
+     * retryCount resubscriptions.
+     * 
    
+     * Any and all items emitted by the source Observable will be emitted by
+     * the resulting Observable, even those emitted during failed subscriptions.
+     * For example, if an Observable fails at first but emits [1, 2] then
+     * succeeds the second time and emits [1, 2, 3, 4, 5] then the complete
+     * sequence of emissions and notifications would be
+     * [1, 2, 1, 2, 3, 4, 5, onCompleted].
      * 
-     * @param 
-     *            the result type
-     * @param selector
-     *            function which can use the multicasted source
-     *            sequence as many times as needed, without causing multiple
-     *            subscriptions to the source sequence. Subscribers to the given
-     *            source will receive all notifications of the source from the time
-     *            of the subscription on.
-     * @return an observable sequence that is the result of invoking the
-     *         selector on a connectable observable sequence that shares a single
-     *         subscription to the underlying sequence.
+     * @param retryCount
+     *            number of retry attempts before failing
+     * @return the source Observable modified with retry logic
+     * @see RxJava Wiki: retry()
      */
-    public  Observable publish(Func1, ? extends Observable> selector) {
-        return multicast(new Func0>() {
-            @Override
-            public Subject call() {
-                return PublishSubject.create();
-            }
-        }, selector);
+    public Observable retry(int retryCount) {
+        return create(OperationRetry.retry(this, retryCount));
     }
 
     /**
-     * Create an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
-     * initialValue.
+     * Returns an Observable that emits the results of sampling the items
+     * emitted by the source Observable at a specified time interval.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the result type
-     * @param selector
-     *            function which can use the multicasted source
-     *            sequence as many times as needed, without causing multiple
-     *            subscriptions to the source sequence. Subscribers to the given
-     *            source will receive all notifications of the source from the time
-     *            of the subscription on
-     * @param initialValue
-     *            the initial value of the underlying BehaviorSubject
-     * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
-     *         initialValue
+     * @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
+     * @see RxJava Wiki: sample()
      */
-    public  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
-        return multicast(new Func0>() {
-            @Override
-            public Subject call() {
-                return BehaviorSubject.create(initialValue);
-            }
-        }, selector);
+    public Observable sample(long period, TimeUnit unit) {
+        return create(OperationSample.sample(this, period, unit));
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that emits only the last item
-     * emitted by the source Observable.
+     * Returns an Observable that emits the results of sampling the items
+     * emitted by the source Observable at a specified time interval.
      * 
    
-     * 
+     * 
      * 
-     * @return a {@link ConnectableObservable}
-     * @see RxJava Wiki: publishLast()
+     * @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
+     * @see RxJava Wiki: sample()
      */
-    public ConnectableObservable publishLast() {
-        return OperationMulticast.multicast(this, AsyncSubject. create());
+    public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationSample.sample(this, period, unit, scheduler));
     }
 
     /**
-     * Create an observable sequence that is the result of invoking the
-     * selector on a connectable observable sequence that shares a single
-     * subscription to the underlying sequence containing only the last
-     * notification.
+     * Return an Observable that emits the results of sampling the items emitted
+     * by this Observable when the sampler Observable emits an item
+     * or completes.
+     * 
    
+     * 
      * 
-     * @param 
-     *            the result type
-     * @param selector
-     *            function which can use the multicasted source
-     *            sequence as many times as needed, without causing multiple
-     *            subscriptions to the source sequence. Subscribers to the given
-     *            source will only receive the last notification of the source
-     * @return an observable sequence that is the result of invoking the
-     *         selector on a connectable observable sequence that shares a single
-     *         subscription to the underlying sequence containing only the last
-     *         notification.
+     * @param sampler
+     *            the Observable to use for sampling the source Observable
+     * @return an Observable that emits the results of sampling the items
+     *         emitted by this Observable whenever the sampler
+     *         Observable emits an item or completes
+     * @see RxJava Wiki: sample()
      */
-    public  Observable publishLast(Func1, ? extends Observable> selector) {
-        return multicast(new Func0>() {
-            @Override
-            public Subject call() {
-                return AsyncSubject.create();
-            }
-        }, selector);
-    }
-
-    /**
-     * Synonymous with reduce().
-     * 
    
-     * 
-     * 
-     * @see RxJava Wiki: reduce()
-     * @see #reduce(Func2)
-     * @deprecated use #reduce(Func2)
-     */
-    @Deprecated
-    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" here, is sometimec called
-     * "aggregate," "fold," "accumulate," "compress," or "inject" in other
-     * programming contexts. Groovy, for instance, has an inject
-     * method that does a similar operation on lists.
-     * 
-     * @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 RxJava Wiki: reduce()
-     * @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);
-    }
-
-    /**
-     * Collect values into a single mutable data structure.
-     * 
    
-     * A simplified version of `reduce` that does not need to return the state on each pass.
-     * 
    
-     * 
-     * @param state
-     * @param collector
-     * @return
-     */
-    public  Observable collect(R state, final Action2 collector) {
-        Func2 accumulator = new Func2() {
-
-            @Override
-            public R call(R state, T value) {
-                collector.call(state, value);
-                return state;
-            }
-
-        };
-        return reduce(state, accumulator);
-    }
-
-    /**
-     * Synonymous with reduce().
-     * 
    
-     * 
-     * 
-     * @see RxJava Wiki: reduce()
-     * @see #reduce(Object, Func2)
-     * @deprecated use #reduce(Object, Func2)
-     */
-    @Deprecated
-    public  Observable aggregate(R initialValue, Func2 accumulator) {
-        return reduce(initialValue, accumulator);
+    public  Observable sample(Observable sampler) {
+        return create(new OperationSample.SampleWithObservable(this, sampler));
     }
 
     /**
@@ -6251,62 +6337,6 @@ 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
-     * @see RxJava Wiki: sample()
-     */
-    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
-     * @see RxJava Wiki: sample()
-     */
-    public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationSample.sample(this, period, unit, scheduler));
-    }
-
-    /**
-     * Return an Observable that emits the results of sampling the items emitted
-     * by this Observable when the sampler Observable emits an item
-     * or completes.
-     * 
    
-     * 
-     * 
-     * @param sampler
-     *            the Observable to use for sampling the source Observable
-     * @return an Observable that emits the results of sampling the items
-     *         emitted by this Observable whenever the sampler
-     *         Observable emits an item or completes
-     * @see RxJava Wiki: sample()
-     */
-    public  Observable sample(Observable sampler) {
-        return create(new OperationSample.SampleWithObservable(this, sampler));
-    }
-
     /**
      * 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
@@ -6337,76 +6367,6 @@ 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
-     * @see RxJava Wiki: all()
-     */
-    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.
-     * 
    
-     * 
-     * 
-     * @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 Observable emits
-     * @see RxJava Wiki: skip()
-     */
-    public Observable skip(int num) {
-        return create(OperationSkip.skip(this, num));
-    }
-
-    /**
-     * Create an Observable that skips values before the given time ellapses.
-     * 
    
-     * 
-     * 
-     * @param time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
-     * @return an Observable that skips values before the given time ellapses
-     * @see RxJava Wiki: skip()
-     */
-    public Observable skip(long time, TimeUnit unit) {
-        return skip(time, unit, Schedulers.threadPoolForComputation());
-    }
-
-    /**
-     * Create an Observable that skips values before the given time elapses
-     * while waiting on the given scheduler.
-     * 
    
-     * 
-     * 
-     * @param time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the scheduler where the timed wait happens
-     * @return an Observable that skips values before the given time elapses
-     *         while waiting on the given scheduler
-     * @see RxJava Wiki: skip()
-     */
-    public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
-    }
-
     /**
      * If the Observable completes after emitting a single item, return an
      * Observable containing that item. If it emits more than one item or no
@@ -6501,142 +6461,106 @@ public Observable singleOrDefault(T defaultValue, Func1 p
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the
-     * source Observable, or an IllegalArgumentException if the
-     * source {@link Observable} is empty.
+     * Returns an Observable that skips the first num items emitted
+     * by the source Observable and emits the remainder.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits only the very first item from the
-     *         source, or an IllegalArgumentException if the source {@link Observable} is empty.
-     * @see RxJava Wiki: first()
-     * @see MSDN: Observable.firstAsync()
+     * @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 Observable emits
+     * @see RxJava Wiki: skip()
      */
-    public Observable first() {
-        return take(1).single();
+    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 that satisfies a given condition, or an
-     * IllegalArgumentException if no such items are emitted.
+     * Create an Observable that skips values before the given time ellapses.
      * 
    
-     * 
+     * 
      * 
-     * @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 an IllegalArgumentException if no such items are emitted.
-     * @see RxJava Wiki: first()
-     * @see MSDN: Observable.firstAsync()
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @return an Observable that skips values before the given time ellapses
+     * @see RxJava Wiki: skip()
      */
-    public Observable first(Func1 predicate) {
-        return takeFirst(predicate).single();
+    public Observable skip(long time, TimeUnit unit) {
+        return skip(time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the
-     * source Observable, or a default item.
+     * Create an Observable that skips values before the given time elapses
+     * while waiting on the given scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @param defaultValue
-     *            the default item 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 item if the source Observable completes
-     *         without emitting a single item
-     * @see RxJava Wiki: firstOrDefault()
-     * @see MSDN: Observable.firstOrDefaultAsync()
-     */
-    public Observable firstOrDefault(T defaultValue) {
-        return take(1).singleOrDefault(defaultValue);
-    }
-
-    /**
-     * Returns an Observable that emits only the very first item emitted by the
-     * source Observable that satisfies a given condition, or a default item
-     * otherwise.
-     * 
    
-     * 
-     * 
-     * @param predicate
-     *            the condition any source emitted item has to satisfy
-     * @param defaultValue
-     *            the default item 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 item otherwise
-     * @see RxJava Wiki: firstOrDefault()
-     * @see MSDN: Observable.firstOrDefaultAsync()
-     */
-    public Observable firstOrDefault(T defaultValue, Func1 predicate) {
-        return takeFirst(predicate).singleOrDefault(defaultValue);
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by the source
-     * Observable or a specified default item if the source Observable is empty.
-     * 
    
-     * 
-     * 
-     * @param defaultValue
-     *            the item to emit if the source Observable emits no
-     *            items
-     * @return an Observable that emits either the specified default item if the
-     *         source Observable emits no items, or the items emitted by the
-     *         source Observable
-     * @see RxJava Wiki: defaultIfEmpty()
-     * @see MSDN: Observable.DefaultIfEmpty
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler where the timed wait happens
+     * @return an Observable that skips values before the given time elapses
+     *         while waiting on the given scheduler
+     * @see RxJava Wiki: skip()
      */
-    public Observable defaultIfEmpty(T defaultValue) {
-        return create(OperationDefaultIfEmpty.defaultIfEmpty(this, defaultValue));
+    public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
     }
 
     /**
-     * Returns an Observable that emits only the first num items
-     * emitted by the source Observable.
+     * Bypasses a specified number of items at the end of an Observable
+     * sequence.
      * 
    
-     * 
+     * This operator accumulates a queue long enough to store the first
+     * count items. As more items are received, items are taken
+     * from the front of the queue and emitted by the returned Observable. This
+     * causes such items to be delayed.
      * 
    
-     * 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 emit
-     * @return an Observable that emits only the first num items
-     *         emitted by the source Observable, or all of the items from the
-     *         source Observable if that Observable emits fewer than
-     *         num items
-     * @see RxJava Wiki: take()
+     * @param count
+     *            number of items to bypass at the end of the source sequence
+     * @return an Observable that emits the items emitted by the source
+     *         Observable except for the bypassed ones at the end
+     * @throws IndexOutOfBoundsException
+     *             if count is less than zero
+     * @see RxJava Wiki: skipLast()
+     * @see MSDN: Observable.SkipLast
      */
-    public Observable take(final int num) {
-        return create(OperationTake.take(this, num));
+    public Observable skipLast(int count) {
+        return create(OperationSkipLast.skipLast(this, count));
     }
 
     /**
-     * Create an Observable that emits the emitted items from the source
-     * Observable before the time runs out.
+     * Create an Observable that skips values emitted in a time window before
+     * the source completes.
      * 
    
-     * 
+     * 
      * 
      * @param time
      *            the length of the time window
      * @param unit
      *            the time unit
-     * @return an Observable that emits the emitted items from the source
-     *         Observable before the time runs out
-     * @see RxJava Wiki: take()
+     * @return an Observable that skips values emitted in a time window before
+     *         the source completes
+     * @see RxJava Wiki: skipLast()
+     * @see MSDN: Observable.SkipLast
      */
-    public Observable take(long time, TimeUnit unit) {
-        return take(time, unit, Schedulers.threadPoolForComputation());
+    public Observable skipLast(long time, TimeUnit unit) {
+        return skipLast(time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Create an Observable that emits the emitted items from the source
-     * Observable before the time runs out, waiting on the given scheduler.
+     * Create an Observable that skips values emitted in a time window before
+     * the source completes by using the given scheduler as time source.
      * 
    
-     * 
+     * 
      * 
      * @param time
      *            the length of the time window
@@ -6644,1142 +6568,1379 @@ public Observable take(long time, TimeUnit unit) {
      *            the time unit
      * @param scheduler
      *            the scheduler used for time source
-     * @return an Observable that emits the emitted items from the source
-     *         Observable before the time runs out, waiting on the given
-     *         scheduler
-     * @see RxJava Wiki: take()
+     * @return an Observable that skips values emitted in a time window before
+     *         the source completes by using the given scheduler as time source
+     * @see RxJava Wiki: skipLast()
+     * @see MSDN: Observable.SkipLast
      */
-    public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
+    public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
     }
 
     /**
-     * Returns an Observable that emits items emitted by the source Observable
-     * so long as a specified condition is true.
+     * Return an Observable that skips items from the source Observable until
+     * the secondary Observable emits an item.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: takeWhile()
+     * @param other
+     *            the other Observable that has to emit an item before this
+     *            Observable's elements are relayed
+     * @return an Observable that skips items from the source Observable
+     *         until the secondary Observable emits an item.
+     * @see RxJava Wiki: skipUntil()
+     * @see MSDN: Observable.SkipUntil
      */
-    public Observable takeWhile(final Func1 predicate) {
-        return create(OperationTakeWhile.takeWhile(this, predicate));
+    public  Observable skipUntil(Observable other) {
+        return create(new OperationSkipUntil(this, other));
     }
 
     /**
-     * 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
-     * of items.
+     * Returns an Observable that bypasses all items from the source Observable
+     * as long as a specified condition holds true, but emits all further
+     * source items as soon as the condition becomes false.
      * 
    
-     * 
+     * 
      * 
      * @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
-     * @see RxJava Wiki: takeWhileWithIndex()
+     *            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 RxJava Wiki: skipWhile()
+     * @see MSDN: Observable.SkipWhile
      */
-    public Observable takeWhileWithIndex(final Func2 predicate) {
-        return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
+    public Observable skipWhile(Func1 predicate) {
+        return create(OperationSkipWhile.skipWhile(this, predicate));
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the
-     * source Observable.
+     * Returns an Observable that bypasses all items from the source Observable
+     * as long as the specified condition holds true, but emits all further
+     * source items as soon as the condition becomes false.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits only the very first item from the
-     *         source, or an empty Observable if the source Observable completes
-     *         without emitting a single item
-     * @deprecated Use take(1) directly.
-     * @see RxJava Wiki: first()
-     * @see MSDN: Observable.firstAsync()
+     * @param predicate
+     *            a function to test each item emitted from the source
+     *            Observable for a condition. It receives the emitted item
+     *            as the first parameter and the index of the emitted item
+     *            as a second parameter.
+     * @return an Observable that emits all items from the source Observable as
+     *         soon as the condition becomes false
+     * @see RxJava Wiki: skipWhileWithIndex()
+     * @see MSDN: Observable.SkipWhile
      */
-    @Deprecated
-    public Observable takeFirst() {
-        return take(1);
+    public Observable skipWhileWithIndex(Func2 predicate) {
+        return create(OperationSkipWhile.skipWhileWithIndex(this, predicate));
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the
-     * source Observable that satisfies a given condition.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @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 an empty Observable if the
-     *         source Observable completes without emitting a single matching
-     *         item
-     * @see RxJava Wiki: first()
-     * @see MSDN: Observable.firstAsync()
+     * @param values
+     *            Iterable of the items you want the modified Observable to
+     *            emit first
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable takeFirst(Func1 predicate) {
-        return filter(predicate).take(1);
+    public Observable startWith(Iterable values) {
+        return concat(Observable. from(values), this);
     }
 
     /**
-     * Returns an Observable that emits only the last count items
-     * emitted by the source Observable.
+     * Emit a specified set of items with the specified scheduler before
+     * beginning to emit items from 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
-     * @see RxJava Wiki: takeLast()
+     * @param values
+     *            iterable of the items you want the modified Observable to
+     *            emit first
+     * @param scheduler
+     *            the scheduler to emit the prepended values on
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
+     * @see MSDN: Observable.StartWith
      */
-    public Observable takeLast(final int count) {
-        return create(OperationTakeLast.takeLast(this, count));
+    public Observable startWith(Iterable values, Scheduler scheduler) {
+        return concat(from(values, scheduler), this);
     }
 
     /**
-     * Return an Observable which emits the items from the source Observable
-     * that were emitted not before it completed minus a time window.
+     * Emit a specified item before beginning to emit items from the source
+     * Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @return an Observable that emits the items from the source Observable
-     *         that were emitted not before it completed minus a time window
+     * @param t1
+     *            item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable takeLast(long time, TimeUnit unit) {
-        return takeLast(time, unit, Schedulers.threadPoolForComputation());
+    public Observable startWith(T t1) {
+        return concat(Observable. from(t1), this);
     }
 
     /**
-     * Return an Observable that emits the items from the source Observable that
-     * were emitted not before the source Observable completed minus a time
-     * window, where the timing information is provided by the given scheduler.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the Scheduler that provides the timestamps for the
-     *            Observed items
-     * @return an Observable that emits the items from the source Observable
-     *         that were emitted not before it completed minus a time window,
-     *         where the timing information is provided by the given Scheduler
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
+    public Observable startWith(T t1, T t2) {
+        return concat(Observable. from(t1, t2), this);
     }
 
     /**
-     * Return an Observable that emits at most a specified number of items from
-     * the source Observable that were emitted not before it completed minus a
-     * time window.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @return an Observable that emits at most {@code count} items from the
-     *         source Observable which were emitted not before it completed
-     *         minus a time window
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable takeLast(int count, long time, TimeUnit unit) {
-        return takeLast(count, time, unit, Schedulers.threadPoolForComputation());
+    public Observable startWith(T t1, T t2, T t3) {
+        return concat(Observable. from(t1, t2, t3), this);
     }
 
     /**
-     * Return an Observable that emits at most a specified number of items from
-     * the source Observable that were emitted not before it completed minus a
-     * time window, where the timing information is provided by a given
-     * scheduler.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the Scheduler that provides the timestamps for the
-     *            observed items
-     * @return an Observable that emits at most {@code count} items from the
-     *         source Observable which were emitted not before it completed
-     *         minus a time window, where the timing information is provided by
-     *         the given {@code scheduler}
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
-        if (count < 0) {
-            throw new IllegalArgumentException("count >= 0 required");
-        }
-        return create(OperationTakeLast.takeLast(this, count, time, unit, scheduler));
+    public Observable startWith(T t1, T t2, T t3, T t4) {
+        return concat(Observable. from(t1, t2, t3, t4), this);
     }
 
     /**
-     * Return an Observable that emits single List containing the last {@code count} elements emitted by the source Observable.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the number of items to take last
-     * @return an Observable that emits a single list containing the last {@code count} elements emitted by the source Observable
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable> takeLastBuffer(int count) {
-        return takeLast(count).toList();
+    public Observable startWith(T t1, T t2, T t3, T t4, T t5) {
+        return concat(Observable. from(t1, t2, t3, t4, t5), this);
     }
 
     /**
-     * Return an Observable that emits single List containing items that were
-     * emitted by the source Observable not before it completed minus a time
-     * window.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @return an Observable that emits single list containing items that were
-     *         were emitted by the source Observable not before it completed
-     *         minus a time window
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable> takeLastBuffer(long time, TimeUnit unit) {
-        return takeLast(time, unit).toList();
+    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);
     }
 
     /**
-     * Return an Observable that emits single List containing items that were
-     * emitted by the source Observable not before it completed minus a time
-     * window, where the timing information is provided by the given Scheduler.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the Scheduler that provides the timestamps for the
-     *            observed items
-     * @return an Observable that emits single list containing items that were
-     *         were emitted by the source Observable not before it completed
-     *         minus a time window, where the timing information is provided by
-     *         the given scheduler
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
-        return takeLast(time, unit, scheduler).toList();
+    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);
     }
 
     /**
-     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
-     * before it completed minus a time window.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
-     *         it completed minus a time window
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
+     * @param t8
+     *            eighth item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
-        return takeLast(count, time, unit).toList();
+    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);
     }
 
     /**
-     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
-     * before it completed minus a time window.
+     * Emit a specified set of items before beginning to emit items from the
+     * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window, relative to the completion of
-     *            the source Observable
-     * @param unit
-     *            the time unit
-     * @param scheduler
-     *            the scheduler that provides the timestamps for the
-     *            observed items
-     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
-     *         it completed minus a time window
+     * @param t1
+     *            first item to emit
+     * @param t2
+     *            second item to emit
+     * @param t3
+     *            third item to emit
+     * @param t4
+     *            fourth item to emit
+     * @param t5
+     *            fifth item to emit
+     * @param t6
+     *            sixth item to emit
+     * @param t7
+     *            seventh item to emit
+     * @param t8
+     *            eighth item to emit
+     * @param t9
+     *            ninth item to emit
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
      */
-    public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
-        return takeLast(count, time, unit, scheduler).toList();
+    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);
     }
 
     /**
-     * Returns an Observable that emits the items from the source Observable
-     * only until the other Observable emits an item.
+     * Emit a specified array of items with the specified scheduler before
+     * beginning to emit items from the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: takeUntil()
+     * @param values
+     *            the items you want the modified Observable to emit first
+     * @param scheduler
+     *            the scheduler to emit the prepended values on
+     * @return an Observable that exhibits the modified behavior
+     * @see RxJava Wiki: startWith()
+     * @see MSDN: Observable.StartWith
      */
-    public  Observable takeUntil(Observable other) {
-        return OperationTakeUntil.takeUntil(this, other);
+    public Observable startWith(T[] values, Scheduler scheduler) {
+        return startWith(Arrays.asList(values), scheduler);
     }
 
     /**
-     * Returns an Observable that bypasses all items from the source Observable
-     * as long as the specified condition holds true, but emits all further
-     * source items as soon as the condition becomes false.
-     * 
    
-     * 
+     * Subscribe and ignore all events.
      * 
-     * @param predicate
-     *            a function to test each item emitted from the source
-     *            Observable for a condition. It receives the emitted item
-     *            as the first parameter and the index of the emitted item
-     *            as a second parameter.
-     * @return an Observable that emits all items from the source Observable as
-     *         soon as the condition becomes false
-     * @see RxJava Wiki: skipWhileWithIndex()
-     * @see MSDN: Observable.SkipWhile
+     * @return
      */
-    public Observable skipWhileWithIndex(Func2 predicate) {
-        return create(OperationSkipWhile.skipWhileWithIndex(this, predicate));
+    public Subscription subscribe() {
+        return protectivelyWrapAndSubscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+                // do nothing
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new OnErrorNotImplementedException(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+                // do nothing
+            }
+
+        });
     }
 
     /**
-     * Returns an Observable that bypasses all items from the source Observable
-     * as long as a specified condition holds true, but emits all further
-     * source items as soon as the condition becomes false.
-     * 
    
-     * 
+     * An {@link Observer} must call an Observable's {@code subscribe} method
+     * in order to receive items and notifications from the Observable.
      * 
-     * @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 RxJava Wiki: skipWhile()
-     * @see MSDN: Observable.SkipWhile
+     * @param onNext
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Observable skipWhile(Func1 predicate) {
-        return create(OperationSkipWhile.skipWhile(this, predicate));
+    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) {
+                throw new OnErrorNotImplementedException(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+                onNext.call(args);
+            }
+
+        });
     }
 
     /**
-     * Bypasses a specified number of items at the end of an Observable
-     * sequence.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
+     * 
+     * @param onNext
+     * @param onError
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
+    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) {
+                onError.call(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+                onNext.call(args);
+            }
+
+        });
+    }
+
+    /**
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
+     * 
+     * @param onNext
+     * @param onError
+     * @param onComplete
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and 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) {
+                onError.call(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+                onNext.call(args);
+            }
+
+        });
+    }
+
+    /**
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
+     * 
+     * @param onNext
+     * @param onError
+     * @param onComplete
+     * @param scheduler
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
+    public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
+        return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
+    }
+
+    /**
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
+     * 
+     * @param onNext
+     * @param onError
+     * @param scheduler
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
+    public Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
+        return subscribeOn(scheduler).subscribe(onNext, onError);
+    }
+
+    /**
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
+     * 
+     * @param onNext
+     * @param scheduler
+     * @return
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
+    public Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
+        return subscribeOn(scheduler).subscribe(onNext);
+    }
+
+    /**
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
      * 
    
-     * This operator accumulates a queue long enough to store the first
-     * count items. As more items are received, items are taken
-     * from the front of the queue and emitted by the returned Observable. This
-     * causes such items to be delayed.
+     * A typical implementation of {@code subscribe} does the following:
+     * 
      
+     * 
    1. It stores a reference to the Observer in a collection object, such as
+     * a {@code List} object.
      2. 
+     * 
    2. 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.
      3. 
+     * 
    
+     * 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 count
-     *            number of items to bypass at the end of the source sequence
-     * @return an Observable that emits the items emitted by the source
-     *         Observable except for the bypassed ones at the end
-     * @throws IndexOutOfBoundsException
-     *             if count is less than zero
-     * @see RxJava Wiki: skipLast()
-     * @see MSDN: Observable.SkipLast
+     * @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 Observable skipLast(int count) {
-        return create(OperationSkipLast.skipLast(this, count));
+    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();
+        }
     }
 
     /**
-     * Create an Observable that skips values emitted in a time window before
-     * the source completes.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in
+     * order to receive items and notifications from the Observable.
      * 
    
-     * 
-     * 
-     * @param time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
-     * @return an Observable that skips values emitted in a time window before
-     *         the source completes
-     * @see RxJava Wiki: skipLast()
-     * @see MSDN: Observable.SkipLast
-     */
-    public Observable skipLast(long time, TimeUnit unit) {
-        return skipLast(time, unit, Schedulers.threadPoolForComputation());
-    }
-
-    /**
-     * Create an Observable that skips values emitted in a time window before
-     * the source completes by using the given scheduler as time source.
+     * A typical implementation of {@code subscribe} does the following:
+     * 
      
+     * 
    1. It stores a reference to the Observer in a collection object, such as
+     * a {@code List} object.
      2. 
+     * 
    2. 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.
      3. 
+     * 
    
+     * 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 time
-     *            the length of the time window
-     * @param unit
-     *            the time unit
+     * @param observer
+     *            the Observer
      * @param scheduler
-     *            the scheduler used for time source
-     * @return an Observable that skips values emitted in a time window before
-     *         the source completes by using the given scheduler as time source
-     * @see RxJava Wiki: skipLast()
-     * @see MSDN: Observable.SkipLast
+     *            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 Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
+    public Subscription subscribe(Observer observer, Scheduler scheduler) {
+        return subscribeOn(scheduler).subscribe(observer);
     }
 
     /**
-     * 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.
+     * Asynchronously subscribes and unsubscribes Observers on the specified {@link Scheduler}.
      * 
    
-     * 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.
-     * @see RxJava Wiki: toList()
+     * @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}
+     * @see RxJava Wiki: subscribeOn()
      */
-    public Observable> toList() {
-        return create(OperationToObservableList.toObservableList(this));
+    public Observable subscribeOn(Scheduler scheduler) {
+        return create(OperationSubscribeOn.subscribeOn(this, scheduler));
     }
 
     /**
-     * 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).
+     * Create an Observable that extracts a double from each of the items
+     * emitted by the source Observable via a function you specify, and then
+     * emits the sum of these doubles.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: toSortedList()
+     * @param valueExtractor
+     *            the function to extract a double from each item
+     *            emitted by the source Observable
+     * @return an Observable that emits the double sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumDouble()
+     * @see MSDN: Observable.Sum
      */
-    public Observable> toSortedList() {
-        return create(OperationToObservableSortedList.toSortedList(this));
+    public Observable sumDouble(Func1 valueExtractor) {
+        return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
     }
 
     /**
-     * Return an Observable that emits the items emitted by the source
-     * Observable, in a sorted order based on a specified comparison function
+     * Create an Observable that extracts a float from each of the items emitted
+     * by the source Observable via a function you specify, and then emits the
+     * sum of these floats.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: toSortedList()
+     * @param valueExtractor
+     *            the function to extract a float from each item
+     *            emitted by the source Observable
+     * @return an Observable that emits the float sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumFloat()
+     * @see MSDN: Observable.Sum
      */
-    public Observable> toSortedList(Func2 sortFunction) {
-        return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
+    public Observable sumFloat(Func1 valueExtractor) {
+        return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Create an Observable that extracts an integer from each of the items
+     * emitted by the source Observable via a function you specify, and then
+     * emits the sum of these integers.
      * 
    
-     * 
+     * 
      * 
-     * @param values
-     *            Iterable of the items you want the modified Observable to
-     *            emit first
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param valueExtractor
+     *            the function to extract an integer from each item
+     *            emitted by the source Observable
+     * @return an Observable that emits the integer sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumInteger()
+     * @see MSDN: Observable.Sum
      */
-    public Observable startWith(Iterable values) {
-        return concat(Observable. from(values), this);
+    public Observable sumInteger(Func1 valueExtractor) {
+        return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
     }
 
     /**
-     * Emit a specified set of items with the specified scheduler before
-     * beginning to emit items from the source Observable.
+     * Create an Observable that extracts a long from each of the items emitted
+     * by the source Observable via a function you specify, and then emits the
+     * sum of these longs.
      * 
    
-     * 
+     * 
      * 
-     * @param values
-     *            iterable of the items you want the modified Observable to
-     *            emit first
-     * @param scheduler
-     *            the scheduler to emit the prepended values on
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
-     * @see MSDN: Observable.StartWith
+     * @param valueExtractor
+     *            the function to extract a long from each item
+     *            emitted by the source Observable
+     * @return an Observable that emits the long sum of the integer values
+     *         corresponding to the items emitted by the source Observable
+     *         transformed by the provided function
+     * @see RxJava Wiki: sumLong()
+     * @see MSDN: Observable.Sum
      */
-    public Observable startWith(Iterable values, Scheduler scheduler) {
-        return concat(from(values, scheduler), this);
+    public Observable sumLong(Func1 valueExtractor) {
+        return create(new OperationSum.SumLongExtractor(this, valueExtractor));
     }
 
     /**
-     * Emit a specified array of items with the specified scheduler before
-     * beginning to emit items from the source Observable.
+     * Creates a new Observable by applying a function that you supply to each
+     * item emitted by the source Observable resulting in an Observable of
+     * Observables. Then a {@link #switchLatest(Observable)} / {@link #switchOnNext(Observable)} is applied.
      * 
    
-     * 
+     * 
      * 
-     * @param values
-     *            the items you want the modified Observable to emit first
-     * @param scheduler
-     *            the scheduler to emit the prepended values on
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
-     * @see MSDN: Observable.StartWith
+     * @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 then switch
      */
-    public Observable startWith(T[] values, Scheduler scheduler) {
-        return startWith(Arrays.asList(values), scheduler);
+    public  Observable switchMap(Func1> func) {
+        return switchOnNext(map(func));
     }
 
     /**
-     * Emit a specified item before beginning to emit items from the source
-     * Observable.
+     * 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 t1
-     *            item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @return an Observable that is a chronologically well-behaved version of
+     *         the source Observable, and that synchronously notifies its {@link Observer}s
+     * @see RxJava Wiki: synchronize()
      */
-    public Observable startWith(T t1) {
-        return concat(Observable. from(t1), this);
+    public Observable synchronize() {
+        return create(OperationSynchronize.synchronize(this));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Accepts an Observable and wraps it in another Observable that ensures
+     * that the resulting Observable is chronologically well-behaved. This is
+     * accomplished by acquiring a mutual-exclusion lock for the object provided
+     * as the lock parameter.
      * 
    
-     * 
+     * 
+     * 
    
+     * 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 t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param lock
+     *            the lock object to synchronize each observer call on
+     * @return an Observable that is a chronologically well-behaved version of
+     *         the source Observable, and that synchronously notifies its {@link Observer}s
+     * @see RxJava Wiki: synchronize()
      */
-    public Observable startWith(T t1, T t2) {
-        return concat(Observable. from(t1, t2), this);
+    public Observable synchronize(Object lock) {
+        return create(OperationSynchronize.synchronize(this, lock));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * 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 t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param num
+     *            the number of items to emit
+     * @return an Observable that emits only the first num items
+     *         emitted by the source Observable, or all of the items from the
+     *         source Observable if that Observable emits fewer than
+     *         num items
+     * @see RxJava Wiki: take()
      */
-    public Observable startWith(T t1, T t2, T t3) {
-        return concat(Observable. from(t1, t2, t3), this);
+    public Observable take(final int num) {
+        return create(OperationTake.take(this, num));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Create an Observable that emits the emitted items from the source
+     * Observable before the time runs out.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits the emitted items from the source
+     *         Observable before the time runs out
+     * @see RxJava Wiki: take()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4) {
-        return concat(Observable. from(t1, t2, t3, t4), this);
+    public Observable take(long time, TimeUnit unit) {
+        return take(time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Create an Observable that emits the emitted items from the source
+     * Observable before the time runs out, waiting on the given scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @param t5
-     *            fifth item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param time
+     *            the length of the time window
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler used for time source
+     * @return an Observable that emits the emitted items from the source
+     *         Observable before the time runs out, waiting on the given
+     *         scheduler
+     * @see RxJava Wiki: take()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5) {
-        return concat(Observable. from(t1, t2, t3, t4, t5), this);
+    public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
+     * Returns an Observable that emits only the very first item emitted by the
      * source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @param t5
-     *            fifth item to emit
-     * @param t6
-     *            sixth item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @return an Observable that emits only the very first item from the
+     *         source, or an empty Observable if the source Observable completes
+     *         without emitting a single item
+     * @deprecated Use take(1) directly.
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
      */
-    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);
+    @Deprecated
+    public Observable takeFirst() {
+        return take(1);
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Returns an Observable that emits only the very first item emitted by the
+     * source Observable that satisfies a given condition.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @param t5
-     *            fifth item to emit
-     * @param t6
-     *            sixth item to emit
-     * @param t7
-     *            seventh item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @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 an empty Observable if the
+     *         source Observable completes without emitting a single matching
+     *         item
+     * @see RxJava Wiki: first()
+     * @see MSDN: Observable.firstAsync()
      */
-    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);
+    public Observable takeFirst(Func1 predicate) {
+        return filter(predicate).take(1);
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Returns an Observable that emits only the last count items
+     * emitted by the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @param t5
-     *            fifth item to emit
-     * @param t6
-     *            sixth item to emit
-     * @param t7
-     *            seventh item to emit
-     * @param t8
-     *            eighth item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @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
+     * @see RxJava Wiki: takeLast()
      */
-    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);
+    public Observable takeLast(final int count) {
+        return create(OperationTakeLast.takeLast(this, count));
     }
 
     /**
-     * Emit a specified set of items before beginning to emit items from the
-     * source Observable.
+     * Return an Observable that emits at most a specified number of items from
+     * the source Observable that were emitted not before it completed minus a
+     * time window.
      * 
    
-     * 
+     * 
      * 
-     * @param t1
-     *            first item to emit
-     * @param t2
-     *            second item to emit
-     * @param t3
-     *            third item to emit
-     * @param t4
-     *            fourth item to emit
-     * @param t5
-     *            fifth item to emit
-     * @param t6
-     *            sixth item to emit
-     * @param t7
-     *            seventh item to emit
-     * @param t8
-     *            eighth item to emit
-     * @param t9
-     *            ninth item to emit
-     * @return an Observable that exhibits the modified behavior
-     * @see RxJava Wiki: startWith()
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits at most {@code count} items from the
+     *         source Observable which were emitted not before it completed
+     *         minus a time window
      */
-    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);
+    public Observable takeLast(int count, long time, TimeUnit unit) {
+        return takeLast(count, time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * 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.
+     * Return an Observable that emits at most a specified number of items from
+     * the source Observable that were emitted not before it completed minus a
+     * time window, where the timing information is provided by a given
+     * scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: groupBy
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            observed items
+     * @return an Observable that emits at most {@code count} items from the
+     *         source Observable which were emitted not before it completed
+     *         minus a time window, where the timing information is provided by
+     *         the given {@code scheduler}
      */
-    public  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
-        return create(OperationGroupBy.groupBy(this, keySelector, elementSelector));
+    public Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count >= 0 required");
+        }
+        return create(OperationTakeLast.takeLast(this, count, time, unit, scheduler));
     }
 
     /**
-     * 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.
+     * Return an Observable which emits the items from the source Observable
+     * that were emitted not before it completed minus a time window.
      * 
    
-     * 
+     * 
      * 
-     * @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
-     * @see RxJava Wiki: groupBy
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits the items from the source Observable
+     *         that were emitted not before it completed minus a time window
      */
-    public  Observable> groupBy(final Func1 keySelector) {
-        return create(OperationGroupBy.groupBy(this, keySelector));
+    public Observable takeLast(long time, TimeUnit unit) {
+        return takeLast(time, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * Return an Observable that correlates two sequences when they overlap and
-     * groups the results.
+     * Return an Observable that emits the items from the source Observable that
+     * were emitted not before the source Observable completed minus a time
+     * window, where the timing information is provided by the given scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @param right
-     *            the other Observable to correlate items from this Observable
-     *            with
-     * @param leftDuration
-     *            function that returns an Observable whose emissions
-     *            indicate the duration of the values of this
-     *            Observable
-     * @param rightDuration
-     *            function that returns an Observable whose emissions
-     *            indicate the duration of the values of the
-     *            right Observable
-     * @param resultSelector
-     *            function that takes an item emitted by each source
-     *            Observable and returns the value to be emitted by
-     *            the resulting Observable
-     * @return an Observable that emits grouped items based on overlapping
-     *         durations from this and another Observable
-     * @see RxJava Wiiki: groupJoin
-     * @see MSDN: Observable.GroupJoin
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            Observed items
+     * @return an Observable that emits the items from the source Observable
+     *         that were emitted not before it completed minus a time window,
+     *         where the timing information is provided by the given Scheduler
      */
-    public  Observable groupJoin(Observable right, Func1> leftDuration,
-            Func1> rightDuration,
-            Func2, ? extends R> resultSelector) {
-        return create(new OperationGroupJoin(this, right, leftDuration, rightDuration, resultSelector));
+    public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
     }
 
     /**
-     * Returns an Observable that emits true if the source
-     * Observable is empty, otherwise false.
-     * 
    
-     * In Rx.Net this is negated as the any operator but we renamed
-     * this in RxJava to better match Java naming idioms.
+     * Return an Observable that emits single List containing the last {@code count} elements emitted by the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits a Boolean
-     * @see RxJava Wiki: isEmpty()
-     * @see MSDN: Observable.Any
+     * @param count
+     *            the number of items to take last
+     * @return an Observable that emits a single list containing the last {@code count} elements emitted by the source Observable
      */
-    public Observable isEmpty() {
-        return create(OperationAny.isEmpty(this));
+    public Observable> takeLastBuffer(int count) {
+        return takeLast(count).toList();
     }
 
     /**
-     * Returns an Observable that emits the last item emitted by the source or
-     * notifies observers of an IllegalArgumentException if the
-     * source Observable is empty.
+     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
+     * before it completed minus a time window.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits the last item from the source Observable
-     *         or notifies observers of an error
-     * @see RxJava Wiki: last()
-     * @see MSDN: Observable.lastAsync()
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
+     *         it completed minus a time window
      */
-    public Observable last() {
-        return takeLast(1).single();
+    public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
+        return takeLast(count, time, unit).toList();
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source
-     * Observable that satisfies a given condition, or an
-     * IllegalArgumentException if no such items are emitted.
+     * Return an Observable that emits a single List containing at most {@code count} items from the source Observable that were emitted not
+     * before it completed minus a time window.
      * 
    
-     * 
+     * 
      * 
-     * @param predicate
-     *            the condition any source emitted item has to satisfy
-     * @return an Observable that emits only the last item satisfying the given
-     *         condition from the source, or an IllegalArgumentException if no
-     *         such items are emitted
-     * @throws IllegalArgumentException
-     *             if no such itmes are emmited
-     * @see RxJava Wiki: last()
-     * @see MSDN: Observable.lastAsync()
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the scheduler that provides the timestamps for the
+     *            observed items
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
+     *         it completed minus a time window
      */
-    public Observable last(Func1 predicate) {
-        return filter(predicate).takeLast(1).single();
+    public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
+        return takeLast(count, time, unit, scheduler).toList();
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source
-     * Observable, or a default item if the source is empty.
+     * Return an Observable that emits single List containing items that were
+     * emitted by the source Observable not before it completed minus a time
+     * window.
      * 
    
-     * 
+     * 
      * 
-     * @param defaultValue
-     *            the default item to emit if the source Observable is
-     *            empty
-     * @return an Observable that emits only the last item from the source, or a
-     *         default item if the source is empty
-     * @see RxJava Wiki: lastOrDefault()
-     * @see MSDN: Observable.lastOrDefaultAsync()
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @return an Observable that emits single list containing items that were
+     *         were emitted by the source Observable not before it completed
+     *         minus a time window
      */
-    public Observable lastOrDefault(T defaultValue) {
-        return takeLast(1).singleOrDefault(defaultValue);
+    public Observable> takeLastBuffer(long time, TimeUnit unit) {
+        return takeLast(time, unit).toList();
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source
-     * Observable that satisfies a given condition, or a default item otherwise.
+     * Return an Observable that emits single List containing items that were
+     * emitted by the source Observable not before it completed minus a time
+     * window, where the timing information is provided by the given Scheduler.
      * 
    
-     * 
+     * 
      * 
-     * @param defaultValue
-     *            the default item to emit if the source Observable
-     *            doesn't emit anything that satisfies the given
-     *            condition
-     * @param predicate
-     *            the condition any source emitted item has to satisfy
-     * @return an Observable that emits only the last item from the source that
-     *         satisfies the given condition, or a default item otherwise
-     * @see RxJava Wiki: lastOrDefault()
-     * @see MSDN: Observable.lastOrDefaultAsync()
+     * @param time
+     *            the length of the time window, relative to the completion of
+     *            the source Observable
+     * @param unit
+     *            the time unit
+     * @param scheduler
+     *            the Scheduler that provides the timestamps for the
+     *            observed items
+     * @return an Observable that emits single list containing items that were
+     *         were emitted by the source Observable not before it completed
+     *         minus a time window, where the timing information is provided by
+     *         the given scheduler
+     */
+    public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
+        return takeLast(time, unit, scheduler).toList();
+    }
+
+    /**
+     * 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
+     * @see RxJava Wiki: takeUntil()
      */
-    public Observable lastOrDefault(T defaultValue, Func1 predicate) {
-        return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
+    public  Observable takeUntil(Observable other) {
+        return OperationTakeUntil.takeUntil(this, other);
     }
 
     /**
-     * Returns an Observable that counts the total number of items emitted by
-     * the source Observable and emits this count as a 64-bit long.
+     * Returns an Observable that emits items emitted by the source Observable
+     * so long as a specified condition is true.
      * 
    
-     * 
+     * 
      * 
-     * @return an Observable that emits the number of items emitted by the
-     *         source Observable as its single, 64-bit long item
-     * @see RxJava Wiki: count()
-     * @see MSDN: Observable.LongCount
-     * @see #count()
+     * @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
+     * @see RxJava Wiki: takeWhile()
      */
-    public Observable longCount() {
-        return reduce(0L, new Func2() {
-            @Override
-            public Long call(Long t1, T t2) {
-                return t1 + 1;
-            }
-        });
+    public Observable takeWhile(final Func1 predicate) {
+        return create(OperationTakeWhile.takeWhile(this, predicate));
     }
 
     /**
-     * Converts an Observable into a {@link BlockingObservable} (an Observable
-     * with blocking operators).
+     * 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
+     * of items.
+     * 
    
+     * 
      * 
-     * @return a BlockingObservable version of this Observable
-     * @see RxJava Wiki: Blocking Observable Operators
+     * @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
+     * @see RxJava Wiki: takeWhileWithIndex()
      */
-    public BlockingObservable toBlockingObservable() {
-        return BlockingObservable.from(this);
+    public Observable takeWhileWithIndex(final Func2 predicate) {
+        return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
     }
 
     /**
-     * Converts the items emitted by an Observable to the specified type.
+     * Matches when the Observable has an available item and projects the item
+     * by invoking the selector function.
      * 
    
-     * 
+     * 
      * 
-     * @param klass
-     *            the target class type which the items will be converted to
-     * @return an Observable that emits each item from the source Observable
-     *         converted to the specified type
-     * @see RxJava Wiki: cast()
-     * @see MSDN: Observable.Cast
+     * @param selector
+     *            selector that will be invoked for items emitted by the
+     *            source Observable
+     * @return a Plan that produces the projected results, to be fed (with other
+     *         Plans) to the {@link #when} operator
+     * @throws NullPointerException
+     *             if selector is null
+     * @see RxJava Wiki: then()
+     * @see MSDN: Observable.Then
      */
-    public  Observable cast(final Class klass) {
-        return create(OperationCast.cast(this, klass));
+    public  Plan0 then(Func1 selector) {
+        return OperationJoinPatterns.then(this, selector);
     }
 
     /**
-     * Filters the items emitted by an Observable based on the specified type.
+     * Throttles by skipping items emitted by the source Observable until
+     * windowDuration passes and then emitting the next item
+     * emitted by the source Observable.
      * 
    
-     * 
+     * This differs from {@link #throttleLast} in that this only tracks passage
+     * of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * 
    
+     * 
      * 
-     * @param klass
-     *            the class type to filter the items emitted by the source
-     *            Observable
-     * @return an Observable that emits items from the source Observable of
-     *         type klass.
-     * @see RxJava Wiki: ofType()
-     * @see MSDN: Observable.OfType
+     * @param windowDuration
+     *            time to wait before emitting another item after
+     *            emitting the last item
+     * @param unit
+     *            the unit of time for the specified timeout
+     * @return an Observable that performs the throttle operation
+     * @see RxJava Wiki: throttleFirst()
      */
-    public  Observable ofType(final Class klass) {
-        return filter(new Func1() {
-            public Boolean call(T t) {
-                return klass.isInstance(t);
-            }
-        }).cast(klass);
+    public Observable throttleFirst(long windowDuration, TimeUnit unit) {
+        return create(OperationThrottleFirst.throttleFirst(this, windowDuration, unit));
     }
 
     /**
-     * Ignores all items emitted by an Observable and only calls
-     * onCompleted or onError.
+     * Throttles by skipping items emitted by the source Observable until
+     * skipDuration passes and then emitting the next item emitted
+     * by the source Observable.
      * 
    
-     * 
+     * This differs from {@link #throttleLast} in that this only tracks passage
+     * of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * 
    
+     * 
      * 
-     * @return an empty Observable that only calls onCompleted or
-     *         onError
-     * @see RxJava Wiki: ignoreElements()
-     * @see MSDN: Observable.IgnoreElements
+     * @param skipDuration
+     *            time to wait before emitting another item after
+     *            emitting the last item
+     * @param unit
+     *            the unit of time for the specified timeout
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle timeout for each event
+     * @return an Observable that performs the throttle operation
+     * @see RxJava Wiki: throttleFirst()
      */
-    public Observable ignoreElements() {
-        return filter(alwaysFalse());
+    public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationThrottleFirst.throttleFirst(this, skipDuration, unit, scheduler));
     }
 
     /**
-     * Applies a timeout policy for each item emitted by the Observable, using
-     * the specified scheduler to run timeout timers. If the next item isn't
-     * observed within the specified timeout duration starting from its
-     * predecessor, observers are notified of a TimeoutException.
+     * Throttles by emitting the last item from the source Observable that falls
+     * in each interval defined by intervalDuration.
      * 
    
-     * 
+     * This differs from {@link #throttleFirst} in that this ticks along at a
+     * scheduled interval whereas {@link #throttleFirst} does not tick, it just
+     * tracks passage of time.
+     * 
    
+     * 
      * 
-     * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time which applies to the
-     *            timeout argument.
-     * @return the source Observable modified to notify observers of a
-     *         TimeoutException in case of a timeout
-     * @see RxJava Wiki: timeout()
-     * @see MSDN: Observable.Timeout
+     * @param intervalDuration
+     *            duration of windows within which the last item
+     *            emitted by the source Observable will be emitted
+     * @param unit
+     *            the unit of time for the specified interval
+     * @return an Observable that performs the throttle operation
+     * @see RxJava Wiki: throttleLast()
+     * @see #sample(long, TimeUnit)
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit));
+    public Observable throttleLast(long intervalDuration, TimeUnit unit) {
+        return sample(intervalDuration, unit);
     }
 
     /**
-     * Applies a timeout policy for each item emitted by the Observable, using
-     * the specified scheduler to run timeout timers. If the next item isn't
-     * observed within the specified timeout duration starting from its
-     * predecessor, a specified fallback Observable produces future items and
-     * notifications from that point on.
+     * Throttles by emitting the last item in each interval defined by
+     * intervalDuration.
      * 
    
-     * 
+     * This differs from {@link #throttleFirst} in that this ticks along at a
+     * scheduled interval whereas {@link #throttleFirst} does not tick, it just
+     * tracks passage of time.
+     * 
    
+     * 
      * 
-     * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time which applies to the
-     *            timeout argument
-     * @param other
-     *            fallback Observable to use in case of a timeout
-     * @return the source Observable modified to switch to the fallback
-     *         Observable in case of a timeout
-     * @see RxJava Wiki: timeout()
-     * @see MSDN: Observable.Timeout
+     * @param intervalDuration
+     *            duration of windows within which the last item
+     *            emitted by the source Observable will be emitted
+     * @param unit
+     *            the unit of time for the specified interval
+     * @param scheduler
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle timeout for each event
+     * @return an Observable that performs the throttle operation
+     * @see RxJava Wiki: throttleLast()
+     * @see #sample(long, TimeUnit, Scheduler)
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, other));
+    public Observable throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
+        return sample(intervalDuration, unit, scheduler);
     }
 
     /**
-     * Applies a timeout policy for each item emitted by the Observable, using
-     * the specified scheduler to run timeout timers. If the next item isn't
-     * observed within the specified timeout duration starting from its
-     * predecessor, the observer is notified of a TimeoutException.
+     * Drops items emitted by an Observable that are followed by newer items
+     * before a timeout value expires. The timer resets on each emission.
      * 
    
-     * 
+     * Note: If events keep firing faster than the timeout then no items will be
+     * emitted by the resulting Observable.
+     * 
    
+     * 
+     * 
    
+     * Information on debounce vs throttle:
+     * 
    
+     * 
    
      * 
      * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time which applies to the
-     *            timeout argument
-     * @param scheduler
-     *            Scheduler to run the timeout timers on
-     * @return the source Observable modified to notify observers of a
-     *         TimeoutException in case of a timeout
-     * @see RxJava Wiki: timeout()
-     * @see MSDN: Observable.Timeout
+     *            the time each item has to be "the most recent" of those
+     *            emitted by the source {@link Observable} to ensure that
+     *            it's not dropped
+     * @param unit
+     *            the {@link TimeUnit} for the timeout
+     * @return an {@link Observable} that filters out items that are too quickly
+     *         followed by newer items
+     * @see RxJava Wiki: throttleWithTimeout()
+     * @see #debounce(long, TimeUnit)
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, scheduler));
+    public Observable throttleWithTimeout(long timeout, TimeUnit unit) {
+        return create(OperationDebounce.debounce(this, timeout, unit));
     }
 
     /**
-     * Applies a timeout policy for each item emitted by the Observable, using
-     * the specified scheduler to run timeout timers. If the next item isn't
-     * observed within the specified timeout duration starting from its
-     * predecessor, a specified fallback Observable sequence produces future
-     * items and notifications from that point on.
+     * Drops items emitted by an Observable that are followed by newer items
+     * before a timeout value expires. The timer resets on each emission.
      * 
    
-     * 
+     * Note: If events keep firing faster than the timeout then no items will be
+     * emitted by the resulting Observable.
+     * 
    
+     * 
+     * 
    
+     * Information on debounce vs throttle:
+     * 
    
+     * 
    
      * 
      * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time which applies to the
-     *            timeout argument
-     * @param other
-     *            Observable to use as the fallback in case of a timeout
+     *            the time each item has to be "the most recent" emitted by
+     *            the {@link Observable} to ensure that it's not dropped
+     * @param unit
+     *            the {@link TimeUnit} for the timeout
      * @param scheduler
-     *            Scheduler to run the timeout timers on
-     * @return the source Observable modified so that it will switch to the
-     *         fallback Observable in case of a timeout
-     * @see RxJava Wiki: timeout()
-     * @see MSDN: Observable.Timeout
+     *            the {@link Scheduler} to use internally to manage the
+     *            timers that handle the timeout for each item
+     * @return an {@link Observable} that filters out items that are too quickly
+     *         followed by newer items
+     * @see RxJava Wiki: throttleWithTimeout()
+     * @see #debounce(long, TimeUnit, Scheduler)
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, other, scheduler));
+    public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
     }
 
     /**
-     * Create an observable which completes if a source item doesn't arrive after the
-     * previous one in the time window specified by the per-item observable.
+     * Records the time interval between consecutive items emitted by an
+     * Observable.
      * 
    
-     * The arrival of the first source item is not timed out.
+     * 
      * 
-     * @param 
-     *            the timeout value type (ignored)
-     * @param timeoutSelector
-     *            function that returns an observable for each source item
-     *            which determines the timeout window for the subsequent source item
-     * @return an observable which completes if a source item doesn't arrive after the
-     *         previous one in the time window specified by the per-item observable.
+     * @return an Observable that emits time interval information items
+     * @see RxJava Wiki: timeInterval()
+     * @see MSDN: Observable.TimeInterval
      */
-    public  Observable timeout(Func1> timeoutSelector) {
-        return timeout(timeoutSelector, Observable. empty());
+    public Observable> timeInterval() {
+        return create(OperationTimeInterval.timeInterval(this));
     }
 
     /**
-     * Create an observable which switches to the other Observable if a source
-     * item doesn't arrive after the
-     * previous one in the time window specified by the per-item observable.
+     * Records the time interval between consecutive items emitted by an
+     * Observable, using the specified Scheduler to compute time intervals.
      * 
    
-     * The arrival of the first source item is not timed out.
+     * 
      * 
-     * @param 
-     *            the timeout value type (ignored)
-     * @param timeoutSelector
-     *            function that returns an observable for each source item
-     *            which determines the timeout window for the subsequent source item
-     * @param other
-     *            the other observable to switch to if the source times out
-     * @return an observable which switches to the other Observable if a source
-     *         item doesn't arrive after the
-     *         previous one in the time window specified by the per-item observable
+     * @param scheduler
+     *            Scheduler used to compute time intervals
+     * @return an Observable that emits time interval information items
+     * @see RxJava Wiki: timeInterval()
+     * @see MSDN: Observable.TimeInterval
      */
-    public  Observable timeout(Func1> timeoutSelector, Observable other) {
-        if (other == null) {
-            throw new NullPointerException("other");
-        }
-        return create(OperationTimeout.timeoutSelector(this, null, timeoutSelector, other));
+    public Observable> timeInterval(Scheduler scheduler) {
+        return create(OperationTimeInterval.timeInterval(this, scheduler));
     }
 
     /**
@@ -7838,1007 +7999,843 @@ public  Observable timeout(Func0> firstTimeoutS
     }
 
     /**
-     * Records the time interval between consecutive items emitted by an
-     * Observable.
-     * 
    
-     * 
-     * 
-     * @return an Observable that emits time interval information items
-     * @see RxJava Wiki: timeInterval()
-     * @see MSDN: Observable.TimeInterval
-     */
-    public Observable> timeInterval() {
-        return create(OperationTimeInterval.timeInterval(this));
-    }
-
-    /**
-     * Records the time interval between consecutive items emitted by an
-     * Observable, using the specified Scheduler to compute time intervals.
-     * 
    
-     * 
-     * 
-     * @param scheduler
-     *            Scheduler used to compute time intervals
-     * @return an Observable that emits time interval information items
-     * @see RxJava Wiki: timeInterval()
-     * @see MSDN: Observable.TimeInterval
-     */
-    public Observable> timeInterval(Scheduler scheduler) {
-        return create(OperationTimeInterval.timeInterval(this, scheduler));
-    }
-
-    /**
-     * Constructs an Observable that creates a dependent resource object.
-     * 
    
-     * 
-     * 
-     * @param resourceFactory
-     *            the factory function to obtain a resource object
-     *            that depends on the Observable
-     * @param observableFactory
-     *            the factory function to obtain an Observable
-     * @return the Observable whose lifetime controls the lifetime of the
-     *         dependent resource object
-     * @see RxJava Wiki: using()
-     * @see MSDN: Observable.Using
-     */
-    public static  Observable using(Func0 resourceFactory, Func1> observableFactory) {
-        return create(OperationUsing.using(resourceFactory, observableFactory));
-    }
-
-    /**
-     * Given multiple Observables, return the one that first emits an item.
-     * 
    
-     * 
-     * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
-     */
-    public static  Observable amb(Observable o1, Observable o2) {
-        return create(OperationAmb.amb(o1, o2));
-    }
-
-    /**
-     * Given multiple Observables, return the one that first emits an item.
-     * 
    
-     * 
-     * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
-     */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3) {
-        return create(OperationAmb.amb(o1, o2, o3));
-    }
-
-    /**
-     * Given multiple Observables, return the one that first emits an item.
-     * 
    
-     * 
-     * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
-     */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) {
-        return create(OperationAmb.amb(o1, o2, o3, o4));
-    }
-
-    /**
-     * Given multiple Observables, return the one that first emits an item.
-     * 
    
-     * 
-     * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @param o5
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
-     */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5));
-    }
-
-    /**
-     * Given multiple Observables, return the one that first emits an item.
+     * Create an observable which completes if a source item doesn't arrive after the
+     * previous one in the time window specified by the per-item observable.
      * 
    
-     * 
+     * The arrival of the first source item is not timed out.
      * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @param o5
-     *            an Observable competing to react first
-     * @param o6
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
+     * @param 
+     *            the timeout value type (ignored)
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
+     * @return an observable which completes if a source item doesn't arrive after the
+     *         previous one in the time window specified by the per-item observable.
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6));
+    public  Observable timeout(Func1> timeoutSelector) {
+        return timeout(timeoutSelector, Observable. empty());
     }
 
     /**
-     * Given multiple Observables, return the one that first emits an item.
+     * Create an observable which switches to the other Observable if a source
+     * item doesn't arrive after the
+     * previous one in the time window specified by the per-item observable.
      * 
    
-     * 
+     * The arrival of the first source item is not timed out.
      * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @param o5
-     *            an Observable competing to react first
-     * @param o6
-     *            an Observable competing to react first
-     * @param o7
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
+     * @param 
+     *            the timeout value type (ignored)
+     * @param timeoutSelector
+     *            function that returns an observable for each source item
+     *            which determines the timeout window for the subsequent source item
+     * @param other
+     *            the other observable to switch to if the source times out
+     * @return an observable which switches to the other Observable if a source
+     *         item doesn't arrive after the
+     *         previous one in the time window specified by the per-item observable
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7));
+    public  Observable timeout(Func1> timeoutSelector, Observable other) {
+        if (other == null) {
+            throw new NullPointerException("other");
+        }
+        return create(OperationTimeout.timeoutSelector(this, null, timeoutSelector, other));
     }
 
     /**
-     * Given multiple Observables, return the one that first emits an item.
+     * Applies a timeout policy for each item emitted by the Observable, using
+     * the specified scheduler to run timeout timers. If the next item isn't
+     * observed within the specified timeout duration starting from its
+     * predecessor, observers are notified of a TimeoutException.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @param o5
-     *            an Observable competing to react first
-     * @param o6
-     *            an Observable competing to react first
-     * @param o7
-     *            an Observable competing to react first
-     * @param o8
-     *            an observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument.
+     * @return the source Observable modified to notify observers of a
+     *         TimeoutException in case of a timeout
+     * @see RxJava Wiki: timeout()
+     * @see MSDN: Observable.Timeout
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
+    public Observable timeout(long timeout, TimeUnit timeUnit) {
+        return create(OperationTimeout.timeout(this, timeout, timeUnit));
     }
 
     /**
-     * Given multiple Observables, return the one that first emits an item.
+     * Applies a timeout policy for each item emitted by the Observable, using
+     * the specified scheduler to run timeout timers. If the next item isn't
+     * observed within the specified timeout duration starting from its
+     * predecessor, a specified fallback Observable produces future items and
+     * notifications from that point on.
      * 
    
-     * 
+     * 
      * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            an Observable competing to react first
-     * @param o3
-     *            an Observable competing to react first
-     * @param o4
-     *            an Observable competing to react first
-     * @param o5
-     *            an Observable competing to react first
-     * @param o6
-     *            an Observable competing to react first
-     * @param o7
-     *            an Observable competing to react first
-     * @param o8
-     *            an Observable competing to react first
-     * @param o9
-     *            an Observable competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param other
+     *            fallback Observable to use in case of a timeout
+     * @return the source Observable modified to switch to the fallback
+     *         Observable in case of a timeout
+     * @see RxJava Wiki: timeout()
+     * @see MSDN: Observable.Timeout
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
+    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other) {
+        return create(OperationTimeout.timeout(this, timeout, timeUnit, other));
     }
 
     /**
-     * Given multiple Observables, return the one that first emits an item.
+     * Applies a timeout policy for each item emitted by the Observable, using
+     * the specified scheduler to run timeout timers. If the next item isn't
+     * observed within the specified timeout duration starting from its
+     * predecessor, a specified fallback Observable sequence produces future
+     * items and notifications from that point on.
      * 
    
-     * 
+     * 
      * 
-     * @param sources
-     *            Observable sources competing to react first
-     * @return an Observable that reflects whichever of the given Observables
-     *         reacted first
-     * @see RxJava Wiki: amb()
-     * @see MSDN: Observable.Amb
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param other
+     *            Observable to use as the fallback in case of a timeout
+     * @param scheduler
+     *            Scheduler to run the timeout timers on
+     * @return the source Observable modified so that it will switch to the
+     *         fallback Observable in case of a timeout
+     * @see RxJava Wiki: timeout()
+     * @see MSDN: Observable.Timeout
      */
-    public static  Observable amb(Iterable> sources) {
-        return create(OperationAmb.amb(sources));
+    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
+        return create(OperationTimeout.timeout(this, timeout, timeUnit, other, scheduler));
     }
 
     /**
-     * Invokes an action for each item emitted by the Observable.
+     * Applies a timeout policy for each item emitted by the Observable, using
+     * the specified scheduler to run timeout timers. If the next item isn't
+     * observed within the specified timeout duration starting from its
+     * predecessor, the observer is notified of a TimeoutException.
      * 
    
-     * 
+     * 
      * 
-     * @param observer
-     *            the action to invoke for each item emitted by the source
-     *            Observable
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnEach()
-     * @see MSDN: Observable.Do
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time which applies to the
+     *            timeout argument
+     * @param scheduler
+     *            Scheduler to run the timeout timers on
+     * @return the source Observable modified to notify observers of a
+     *         TimeoutException in case of a timeout
+     * @see RxJava Wiki: timeout()
+     * @see MSDN: Observable.Timeout
      */
-    public Observable doOnEach(Observer observer) {
-        return create(OperationDoOnEach.doOnEach(this, observer));
+    public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
+        return create(OperationTimeout.timeout(this, timeout, timeUnit, scheduler));
     }
 
     /**
-     * Invokes an action if the source Observable calls onError.
+     * Wraps each item emitted by a source Observable in a {@link Timestamped} object.
      * 
    
-     * 
+     * 
      * 
-     * @param onError
-     *            the action to invoke if the source Observable calls
-     *            onError
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnError()
-     * @see MSDN: Observable.Do
+     * @return an Observable that emits timestamped items from the source
+     *         Observable
+     * @see RxJava Wiki: timestamp()
+     * @see MSDN: Observable.Timestamp
      */
-    public Observable doOnError(final Action1 onError) {
-        Observer observer = new Observer() {
-            @Override
-            public void onCompleted() {
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                onError.call(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-            }
-
-        };
-
-        return create(OperationDoOnEach.doOnEach(this, observer));
+    public Observable> timestamp() {
+        return create(OperationTimestamp.timestamp(this));
     }
 
     /**
-     * Invokes an action when the source Observable calls
-     * onCompleted.
+     * Wraps each item emitted by a source Observable in a {@link Timestamped} object with timestamps provided by the given Scheduler.
      * 
    
-     * 
-     * 
-     * @param onCompleted
-     *            the action to invoke when the source Observable calls
-     *            onCompleted
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnCompleted()
-     * @see MSDN: Observable.Do
-     */
-    public Observable doOnCompleted(final Action0 onCompleted) {
-        Observer observer = new Observer() {
-            @Override
-            public void onCompleted() {
-                onCompleted.call();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-            }
-
-            @Override
-            public void onNext(T args) {
-            }
-
-        };
-
-        return create(OperationDoOnEach.doOnEach(this, observer));
+     * 
+     * 
+     * @param scheduler
+     *            the {@link Scheduler} to use as a time source.
+     * @return an Observable that emits timestamped items from the source
+     *         Observable with timestamps provided by the given Scheduler
+     * @see RxJava Wiki: timestamp()
+     * @see MSDN: Observable.Timestamp
+     */
+    public Observable> timestamp(Scheduler scheduler) {
+        return create(OperationTimestamp.timestamp(this, scheduler));
     }
 
     /**
-     * Invokes an action when the source Observable calls
-     * onNext.
-     * 
    
-     * 
+     * Converts an Observable into a {@link BlockingObservable} (an Observable
+     * with blocking operators).
      * 
-     * @param onNext
-     *            the action to invoke when the source Observable calls
-     *            onNext
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnNext()
-     * @see MSDN: Observable.Do
+     * @return a BlockingObservable version of this Observable
+     * @see RxJava Wiki: Blocking Observable Operators
      */
-    public Observable doOnNext(final Action1 onNext) {
-        Observer observer = new Observer() {
-            @Override
-            public void onCompleted() {
-            }
-
-            @Override
-            public void onError(Throwable e) {
-            }
-
-            @Override
-            public void onNext(T args) {
-                onNext.call(args);
-            }
-
-        };
-
-        return create(OperationDoOnEach.doOnEach(this, observer));
+    public BlockingObservable toBlockingObservable() {
+        return BlockingObservable.from(this);
     }
 
     /**
-     * Invokes an action for each item emitted by the Observable.
+     * 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.
      * 
-     * @param observer
-     *            the action to invoke for each item emitted by the source
-     *            Observable
-     * @return the source Observable with the side-effecting behavior applied
-     * @see RxJava Wiki: doOnEach()
-     * @see MSDN: Observable.Do
+     * @return an Observable that emits a single item: a List containing all of
+     *         the items emitted by the source Observable.
+     * @see RxJava Wiki: toList()
      */
-    public Observable doOnEach(final Action1> onNotification) {
-        Observer observer = new Observer() {
-            @Override
-            public void onCompleted() {
-                onNotification.call(new Notification());
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                onNotification.call(new Notification(e));
-            }
-
-            @Override
-            public void onNext(T v) {
-                onNotification.call(new Notification(v));
-            }
-
-        };
-
-        return create(OperationDoOnEach.doOnEach(this, observer));
+    public Observable> toList() {
+        return create(OperationToObservableList.toObservableList(this));
     }
 
     /**
-     * Whether a given {@link Function} is an internal implementation inside
-     * rx.* packages or not.
+     * Return an Observable that emits a single HashMap containing all items
+     * emitted by the source Observable, mapped by the keys returned by the {@code keySelector} function.
      * 
    
-     * 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.
+     * If a source item maps to the same key, the HashMap will contain the
+     * latest of those items.
      * 
-     * @param o
-     * @return {@code true} if the given function is an internal implementation,
-     *         and {@code false} otherwise.
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as keys in the HashMap
+     * @return an Observable that emits a single HashMap containing the mapped
+     *         items from the source Observable
+     * @see RxJava Wiki: toMap()
+     * @see MSDN: Observable.ToDictionary
      */
-    private boolean isInternalImplementation(Object o) {
-        if (o == null) {
-            return true;
-        }
-        // prevent double-wrapping (yeah it happens)
-        if (o instanceof SafeObserver) {
-            return true;
-        }
-
-        Class clazz = o.getClass();
-        if (internalClassMap.containsKey(clazz)) {
-            //don't need to do reflection
-            return internalClassMap.get(clazz);
-        } else {
-            // we treat the following package as "internal" and don't wrap it
-            Package p = o.getClass().getPackage(); // it can be null
-            Boolean isInternal = (p != null && p.getName().startsWith("rx.operators"));
-            internalClassMap.put(clazz, isInternal);
-            return isInternal;
-        }
+    public  Observable> toMap(Func1 keySelector) {
+        return create(OperationToMap.toMap(this, keySelector));
     }
 
     /**
-     * Creates a pattern that matches when both Observables emit an item.
+     * Return an Observable that emits a single HashMap containing elements with
+     * key and value extracted from the items emitted by the source Observable.
      * 
    
-     * 
+     * 
+     * 
    
+     * If a source item maps to the same key, the HashMap will contain the
+     * latest of those items.
      * 
-     * @param second
-     *            Observable to match with the source Observable
-     * @return Pattern object that matches when both Observables emit an item
-     * @throws NullPointerException
-     *             if right is null
-     * @see RxJava Wiki: and()
-     * @see MSDN: Observable.And
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the HashMap
+     * @return an Observable that emits a single HashMap containing the mapped
+     *         items from the source Observable
+     * @see RxJava Wiki: toMap()
+     * @see MSDN: Observable.ToDictionary
      */
-    public  Pattern2 and(Observable right) {
-        return OperationJoinPatterns.and(this, right);
+    public  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
+        return create(OperationToMap.toMap(this, keySelector, valueSelector));
     }
 
     /**
-     * Matches when the Observable has an available item and projects the item
-     * by invoking the selector function.
+     * Return an Observable that emits a single Map, returned by the
+     * mapFactory function, containing key and value extracted from
+     * the items emitted by the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param selector
-     *            selector that will be invoked for items emitted by the
-     *            source Observable
-     * @return a Plan that produces the projected results, to be fed (with other
-     *         Plans) to the {@link #when} operator
-     * @throws NullPointerException
-     *             if selector is null
-     * @see RxJava Wiki: then()
-     * @see MSDN: Observable.Then
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
+     * @return an Observable that emits a single Map containing the mapped
+     *         items emitted by the source Observable
+     * @see RxJava Wiki: toMap()
      */
-    public  Plan0 then(Func1 selector) {
-        return OperationJoinPatterns.then(this, selector);
+    public  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
+        return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Return an Observable that emits a single HashMap containing an ArrayList
+     * of items, emitted by the source Observable and keyed by the
+     * keySelector function.
      * 
    
-     * 
+     * 
      * 
-     * @param plans
-     *            a series of plans created by use of the {@link #then} operator on patterns
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @throws NullPointerException
-     *             if plans is null
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
+     * @return an Observable that emits a single HashMap containing an ArrayList
+     *         of items mapped from the source Observable
+     * @see RxJava Wiki: toMap()
+     * @see MSDN: Observable.ToLookup
      */
-    public static  Observable when(Plan0... plans) {
-        return create(OperationJoinPatterns.when(plans));
+    public  Observable>> toMultimap(Func1 keySelector) {
+        return create(OperationToMultimap.toMultimap(this, keySelector));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Return an Observable that emits a single HashMap containing an ArrayList
+     * of values, extracted by the valueSelector function, emitted
+     * by the source Observable and keyed by the keySelector
+     * function.
      * 
    
-     * 
+     * 
      * 
-     * @param plans
-     *            a series of plans created by use of the {@link #then} operator on patterns
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @throws NullPointerException
-     *             if plans is null
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the HashMap
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @return an Observable that emits a single HashMap containing an ArrayList
+     *         of items mapped from the source Observable
+     * @see RxJava Wiki: toMap()
+     * @see MSDN: Observable.ToLookup
+     */
+    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
+        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector));
+    }
+
+    /**
+     * Return an Observable that emits a single Map, returned by the
+     * mapFactory function, containing an ArrayList of values,
+     * extracted by the valueSelector function, emitted by the
+     * source Observable and keyed by the keySelector function.
+     * 
    
+     * 
+     * 
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
+     * @return an Observable that emits a single Map containing the list of
+     *         mapped items from the source Observable.
+     * @see RxJava Wiki: toMap()
      */
-    public static  Observable when(Iterable> plans) {
-        if (plans == null) {
-            throw new NullPointerException("plans");
-        }
-        return create(OperationJoinPatterns.when(plans));
+    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
+        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
-     * Joins the results from a pattern.
+     * Return an Observable that emits a single Map, returned by the
+     * mapFactory function, that contains a custom collection of
+     * values, extracted by the valueSelector function, emitted by
+     * the source Observable and keyed by the keySelector function.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            the plan to join
-     * @return an Observable that emits the results from matching a pattern
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param keySelector
+     *            the function that extracts the key from the source
+     *            items to be used as key in the Map
+     * @param valueSelector
+     *            the function that extracts the value from the source
+     *            items to be used as value in the Map
+     * @param mapFactory
+     *            the function that returns an Map instance to be used
+     * @param collectionFactory
+     *            the function that returns a Collection instance
+     *            for a particular key to be used in the Map
+     * @return an Observable that emits a single Map containing the collection
+     *         of mapped items from the source Observable.
+     * @see RxJava Wiki: toMap()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1) {
-        return create(OperationJoinPatterns.when(p1));
+    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
+        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * 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).
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @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
+     * @see RxJava Wiki: toSortedList()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2) {
-        return create(OperationJoinPatterns.when(p1, p2));
+    public Observable> toSortedList() {
+        return create(OperationToObservableSortedList.toSortedList(this));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Return an Observable that emits the items emitted by the source
+     * Observable, in a sorted order based on a specified comparison function
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @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
+     * @see RxJava Wiki: toSortedList()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
-        return create(OperationJoinPatterns.when(p1, p2, p3));
+    public Observable> toSortedList(Func2 sortFunction) {
+        return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Filter items emitted by an Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @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 emitted by the source
+     *         Observable that the filter evaluates as {@code true}
+     * @see RxJava Wiki: where()
+     * @see #filter(Func1)
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4));
+    @Deprecated
+    public Observable where(Func1 predicate) {
+        return filter(predicate);
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows. It emits the current window and opens a new one
+     * when the Observable produced by the specified
+     * closingSelector emits an item. The
+     * closingSelector then creates a new Observable to observe
+     * for the end of the next window.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @param p5
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param closingSelector
+     *            the {@link Func0} used to produce an {@link Observable} for every window created. When this {@link Observable} emits an item, window() emits
+     *            the associated window and begins a new one.
+     * @return an {@link Observable} that emits connected, non-overlapping
+     *         windows when the current {@link Observable} created with the
+     *         closingSelector argument emits an item
+     * @see RxJava Wiki: window()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5));
+    public  Observable> window(Func0> closingSelector) {
+        return create(OperationWindow.window(this, closingSelector));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows, each containing count items. When
+     * the source Observable completes or encounters an error, the resulting
+     * Observable emits the current window and propagates the notification from
+     * the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @param p5
-     *            a plan
-     * @param p6
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param count
+     *            the maximum size of each window before it should be emitted
+     * @return an {@link Observable} that emits connected, non-overlapping
+     *         windows containing at most count items
+     * @see RxJava Wiki: window()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6));
+    public Observable> window(int count) {
+        return create(OperationWindow.window(this, count));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits windows every
+     * skip items, each containing count items.
+     * When the source Observable completes or encounters an error, the
+     * resulting Observable emits the current window and propagates the
+     * notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @param p5
-     *            a plan
-     * @param p6
-     *            a plan
-     * @param p7
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param count
+     *            the maximum size of each window before it should be emitted
+     * @param skip
+     *            how many items need to be skipped before starting a new
+     *            window. Note that if skip and count
+     *            are equal this is the same operation as {@link #window(int)}.
+     * @return an {@link Observable} that emits windows every "skipped"
+     *         items containing at most count items
+     * @see RxJava Wiki: window()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7));
+    public Observable> window(int count, int skip) {
+        return create(OperationWindow.window(this, count, skip));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable starts a new window
+     * periodically, as determined by the timeshift argument. It
+     * emits each window after a fixed timespan, specified by the
+     * timespan argument. When the source Observable completes or
+     * Observable completes or encounters an error, the resulting Observable
+     * emits the current window and propagates the notification from the source
+     * Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @param p5
-     *            a plan
-     * @param p6
-     *            a plan
-     * @param p7
-     *            a plan
-     * @param p8
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param timespan
+     *            the period of time each window collects items 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 that applies to the timespan
+     *            and timeshift arguments
+     * @return an {@link Observable} that emits new windows periodically as a
+     *         fixed timespan has elapsed
+     * @see RxJava Wiki: window()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8));
+    public Observable> window(long timespan, long timeshift, TimeUnit unit) {
+        return create(OperationWindow.window(this, timespan, timeshift, unit));
     }
 
     /**
-     * Joins together the results from several patterns.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable starts a new window
+     * periodically, as determined by the timeshift argument. It
+     * emits each window after a fixed timespan, specified by the
+     * timespan argument. When the source Observable completes or
+     * Observable completes or encounters an error, the resulting Observable
+     * emits the current window and propagates the notification from the source
+     * Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param p1
-     *            a plan
-     * @param p2
-     *            a plan
-     * @param p3
-     *            a plan
-     * @param p4
-     *            a plan
-     * @param p5
-     *            a plan
-     * @param p6
-     *            a plan
-     * @param p7
-     *            a plan
-     * @param p8
-     *            a plan
-     * @param p9
-     *            a plan
-     * @return an Observable that emits the results from matching several
-     *         patterns
-     * @see RxJava Wiki: when()
-     * @see MSDN: Observable.When
+     * @param timespan
+     *            the period of time each window collects items 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 that applies to the timespan
+     *            and timeshift arguments
+     * @param scheduler
+     *            the {@link Scheduler} to use when determining the end
+     *            and start of a window
+     * @return an {@link Observable} that emits new windows periodically as a
+     *         fixed timespan has elapsed
+     * @see RxJava Wiki: window()
      */
-    @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8, Plan0 p9) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9));
+    public Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
     }
 
     /**
-     * Correlates the items emitted by two Observables based on overlapping
-     * durations.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows, each of a fixed duration specified by the
+     * timespan argument. When the source Observable completes or
+     * encounters an error, the resulting Observable emits the current window
+     * and propagates the notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param right
-     *            the second Observable to join items from
-     * @param leftDurationSelector
-     *            a function to select the duration of each
-     *            item emitted by this Observable, used to
-     *            determine overlap
-     * @param rightDurationSelector
-     *            a function to select the duration of each
-     *            item emitted by the right
-     *            Observable, used to determine overlap
-     * @param resultSelector
-     *            a function that computes a result item for any two
-     *            overlapping items emitted by the two Observables
-     * @return an Observable that emits result items computed from source items
-     *         that have an overlapping duration
-     * @see RxJava Wiki: join()
-     * @see MSDN: Observable.Join
+     * @param timespan
+     *            the period of time each window collects items before it
+     *            should be emitted and replaced with a new window
+     * @param unit
+     *            the unit of time that applies to the timespan
+     *            argument
+     * @return an {@link Observable} that emits connected, non-overlapping
+     *         windows with a fixed duration
+     * @see RxJava Wiki: window()
      */
-    public  Observable join(Observable right, Func1> leftDurationSelector,
-            Func1> rightDurationSelector,
-            Func2 resultSelector) {
-        return create(new OperationJoin(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
+    public Observable> window(long timespan, TimeUnit unit) {
+        return create(OperationWindow.window(this, timespan, unit));
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing all items
-     * emitted by the source Observable, mapped by the keys returned by the {@code keySelector} function.
-     * 
    
-     * 
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows, each of a fixed duration as specified by the
+     * timespan argument or a maximum size as specified by the
+     * count argument (whichever is reached first). When the source
+     * Observable completes or encounters an error, the resulting Observable
+     * emits the current window and propagates the notification from the source
+     * Observable.
      * 
    
-     * If a source item maps to the same key, the HashMap will contain the
-     * latest of those items.
+     * 
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as keys in the HashMap
-     * @return an Observable that emits a single HashMap containing the mapped
-     *         items from the source Observable
-     * @see RxJava Wiki: toMap()
-     * @see MSDN: Observable.ToDictionary
+     * @param timespan
+     *            the period of time each window collects items before it
+     *            should be emitted and replaced with a new window
+     * @param unit
+     *            the unit of time that applies to the timespan
+     *            argument
+     * @param count
+     *            the maximum size of each window before it should be emitted
+     * @return an {@link Observable} that emits connected, non-overlapping
+     *         windows after a fixed duration or when the window has reached
+     *         maximum capacity (whichever occurs first)
+     * @see RxJava Wiki: window()
      */
-    public  Observable> toMap(Func1 keySelector) {
-        return create(OperationToMap.toMap(this, keySelector));
+    public Observable> window(long timespan, TimeUnit unit, int count) {
+        return create(OperationWindow.window(this, timespan, unit, count));
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing elements with
-     * key and value extracted from the items emitted by the source Observable.
-     * 
    
-     * 
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows, each of a fixed duration specified by the
+     * timespan argument or a maximum size specified by the
+     * count argument (whichever is reached first). When the source
+     * Observable completes or encounters an error, the resulting Observable
+     * emits the current window and propagates the notification from the source
+     * Observable.
      * 
    
-     * If a source item maps to the same key, the HashMap will contain the
-     * latest of those items.
+     * 
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the HashMap
-     * @param valueSelector
-     *            the function that extracts the value from the source
-     *            items to be used as value in the HashMap
-     * @return an Observable that emits a single HashMap containing the mapped
-     *         items from the source Observable
-     * @see RxJava Wiki: toMap()
-     * @see MSDN: Observable.ToDictionary
+     * @param timespan
+     *            the period of time each window collects items 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} that emits connected non-overlapping
+     *         windows after a fixed duration or when the window has reached
+     *         maximum capacity (whichever occurs first).
+     * @see RxJava Wiki: window()
      */
-    public  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
-        return create(OperationToMap.toMap(this, keySelector, valueSelector));
+    public Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, unit, count, scheduler));
     }
 
     /**
-     * Return an Observable that emits a single Map, returned by the
-     * mapFactory function, containing key and value extracted from
-     * the items emitted by the source Observable.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits connected,
+     * non-overlapping windows, each of a fixed duration as specified by the
+     * timespan argument. When the source Observable completes or
+     * encounters an error, the resulting Observable emits the current window
+     * and propagates the notification from the source Observable.
      * 
    
-     * 
+     * 
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the Map
-     * @param valueSelector
-     *            the function that extracts the value from the source
-     *            items to be used as value in the Map
-     * @param mapFactory
-     *            the function that returns an Map instance to be used
-     * @return an Observable that emits a single Map containing the mapped
-     *         items emitted by the source Observable
-     * @see RxJava Wiki: toMap()
+     * @param timespan
+     *            the period of time each window collects items 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} that emits connected, non-overlapping
+     *         windows with a fixed duration
+     * @see RxJava Wiki: window()
      */
-    public  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
-        return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
+    public Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, unit, scheduler));
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing an ArrayList
-     * of items, emitted by the source Observable and keyed by the
-     * keySelector function.
+     * Creates an Observable that emits windows of items it collects from the
+     * source Observable. The resulting Observable emits windows. These windows
+     * contain those items emitted by the source Observable between the time
+     * when the windowOpenings Observable emits an item and when
+     * the Observable returned by closingSelector emits an item.
      * 
    
-     * 
+     * 
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the HashMap
-     * @return an Observable that emits a single HashMap containing an ArrayList
-     *         of items mapped from the source Observable
-     * @see RxJava Wiki: toMap()
-     * @see MSDN: Observable.ToLookup
+     * @param windowOpenings
+     *            the {@link Observable} that, when it emits an item,
+     *            causes another window to be created
+     * @param closingSelector
+     *            a {@link Func1} that produces an {@link Observable} for every window created. When
+     *            this {@link Observable} emits an item, the
+     *            associated window is closed and emitted
+     * @return an {@link Observable} that emits windows of items emitted by the
+     *         source Observable that are governed by the specified {@link Observable}s emitting items
+     * @see RxJava Wiki: window()
      */
-    public  Observable>> toMultimap(Func1 keySelector) {
-        return create(OperationToMultimap.toMultimap(this, keySelector));
+    public  Observable> window(Observable windowOpenings, Func1> closingSelector) {
+        return create(OperationWindow.window(this, windowOpenings, closingSelector));
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing an ArrayList
-     * of values, extracted by the valueSelector function, emitted
-     * by the source Observable and keyed by the keySelector
-     * function.
-     * 
    
-     * 
+     * Create an Observable which emits non-overlapping windows of items it collects from the
+     * source observable where the boundary of each window is determined by the items
+     * emitted from the boundary observable.
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the HashMap
-     * @param valueSelector
-     *            the function that extracts the value from the source
-     *            items to be used as value in the Map
-     * @return an Observable that emits a single HashMap containing an ArrayList
-     *         of items mapped from the source Observable
-     * @see RxJava Wiki: toMap()
-     * @see MSDN: Observable.ToLookup
+     * @param 
+     *            the window element type (ignored)
+     * @param boundary
+     *            the Observable sequence whose emitted item is used for closing
+     *            and opening windows
+     * @return an Observable which emits non-overlapping windows of items it collects from the
+     *         source observable where the boundary of each window is determined by the items
+     *         emitted from the boundary observable
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector));
+    public  Observable> window(Observable boundary) {
+        return create(OperationWindow.window(this, boundary));
     }
 
     /**
-     * Return an Observable that emits a single Map, returned by the
-     * mapFactory function, containing an ArrayList of values,
-     * extracted by the valueSelector function, emitted by the
-     * source Observable and keyed by the keySelector function.
+     * Return an Observable that pairs up values from this Observable and an
+     * Iterable sequence and applies a function.
      * 
    
-     * 
+     * Note that the other Iterable is evaluated as items appear from this
+     * Observable and is not pre-consumed, allowing zipping infinite streams
+     * on either side.
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the Map
-     * @param valueSelector
-     *            the function that extracts the value from the source
-     *            items to be used as value in the Map
-     * @param mapFactory
-     *            the function that returns an Map instance to be used
-     * @return an Observable that emits a single Map containing the list of
-     *         mapped items from the source Observable.
-     * @see RxJava Wiki: toMap()
+     * @param 
+     *            the other value type
+     * @param 
+     *            the result type
+     * @param other
+     *            the other Iterable sequence
+     * @param zipFunction
+     *            the function that combines the pairs of items of
+     *            this Observable and the Iterable
+     * @return an Observable that pairs up values from this Observable and an
+     *         Iterable sequence and applies a function.
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory));
+    public  Observable zip(Iterable other, Func2 zipFunction) {
+        return create(OperationZip.zipIterable(this, other, zipFunction));
     }
 
     /**
-     * Return an Observable that emits a single Map, returned by the
-     * mapFactory function, that contains a custom collection of
-     * values, extracted by the valueSelector function, emitted by
-     * the source Observable and keyed by the keySelector function.
-     * 
    
-     * 
+     * Return an Observable that pairs up values from this Observable and the other
+     * Observable and applies a function.
      * 
-     * @param keySelector
-     *            the function that extracts the key from the source
-     *            items to be used as key in the Map
-     * @param valueSelector
-     *            the function that extracts the value from the source
-     *            items to be used as value in the Map
-     * @param mapFactory
-     *            the function that returns an Map instance to be used
-     * @param collectionFactory
-     *            the function that returns a Collection instance
-     *            for a particular key to be used in the Map
-     * @return an Observable that emits a single Map containing the collection
-     *         of mapped items from the source Observable.
-     * @see RxJava Wiki: toMap()
+     * @param 
+     *            the other value type
+     * @param 
+     *            the result type
+     * @param other
+     *            the other Observable sequence
+     * @param zipFunction
+     *            the function that combines the pairs of items from both
+     *            observables and returns a new value
+     * @return an Observable that pairs up values from this Observable and the other
+     *         Observable and applies a function.
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));
+    public  Observable zip(Observable other, Func2 zipFunction) {
+        return zip(this, other, zipFunction);
     }
 
     /**
-     * Return an Observable that skips items from the source Observable until
-     * the secondary Observable emits an item.
-     * 
    
-     * 
+     * An Observable that never sends any information to an {@link Observer}.
      * 
-     * @param other
-     *            the other Observable that has to emit an item before this
-     *            Observable's elements are relayed
-     * @return an Observable that skips items from the source Observable
-     *         until the secondary Observable emits an item.
-     * @see RxJava Wiki: skipUntil()
-     * @see MSDN: Observable.SkipUntil
+     * This Observable is useful primarily for testing purposes.
+     * 
+     * @param 
+     *            the type of item emitted by the Observable
      */
-    public  Observable skipUntil(Observable other) {
-        return create(new OperationSkipUntil(this, other));
+    private static class NeverObservable extends Observable {
+        public NeverObservable() {
+            super(new OnSubscribeFunc() {
+
+                @Override
+                public Subscription onSubscribe(Observer t1) {
+                    return Subscriptions.empty();
+                }
+
+            });
+        }
     }
 
     /**
-     * Groups the items emitted by an Observable according to a specified key
-     * selector function until the duration Observable expires for the key.
-     * 
    
-     * 
+     * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
      * 
-     * @param keySelector
-     *            a function to extract the key for each item
-     * @param durationSelector
-     *            a function to signal the expiration of a group
-     * @return an Observable that emits grouped Observables, each of which
-     *         corresponds to a key value and emits all items that share that
-     *         same key value that were emitted during the key's duration
-     * @see RxJava Wiki: groupByUntil()
-     * @see MSDN: Observable.GroupByUntil
+     * @param 
+     *            the type of item emitted by the Observable
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
-        return groupByUntil(keySelector, Functions. identity(), durationSelector);
+    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();
+                }
+
+            });
+        }
+
     }
 
+    private final static ConcurrentHashMap internalClassMap = new ConcurrentHashMap();
+
     /**
-     * Groups the items emitted by an Observable according to specified key and
-     * value selector functions until the duration Observable expires for the
-     * key.
+     * 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.
      * 
-     * @param keySelector
-     *            a function to extract the key for each item
-     * @param valueSelector
-     *            a function to map each source item to an item
-     *            emitted by an Observable group
-     * @param durationSelector
-     *            a function to signal the expiration of a group
-     * @return an Observable that emits grouped Observables, each of which
-     *         corresponds to a key value and emits all items that share that
-     *         same key value that were emitted during the key's duration
-     * @see RxJava Wiki: groupByUntil()
-     * @see MSDN: Observable.GroupByUntil
+     * @param o
+     * @return {@code true} if the given function is an internal implementation,
+     *         and {@code false} otherwise.
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
-        return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector));
-    }
+    private boolean isInternalImplementation(Object o) {
+        if (o == null) {
+            return true;
+        }
+        // prevent double-wrapping (yeah it happens)
+        if (o instanceof SafeObserver) {
+            return true;
+        }
 
+        Class clazz = o.getClass();
+        if (internalClassMap.containsKey(clazz)) {
+            //don't need to do reflection
+            return internalClassMap.get(clazz);
+        } else {
+            // we treat the following package as "internal" and don't wrap it
+            Package p = o.getClass().getPackage(); // it can be null
+            Boolean isInternal = (p != null && p.getName().startsWith("rx.operators"));
+            internalClassMap.put(clazz, isInternal);
+            return isInternal;
+        }
+    }
 }

From fb5a69a1f18db2b61e5bb2c69f524261ef67500c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:10:16 -0800
Subject: [PATCH 214/441] Revert to 1.8 for build to work ...

... until the build server handles 1.10.

Some odd issue with JUnit.
---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2c79588016..c29ff6c5d8 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.8-bin.zip

From 5dae0acb60216c16588810a8795ad5127ac98ce9 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:22:48 -0800
Subject: [PATCH 215/441] Back to 1.10 after building

... this still breaks the release build but I want to encourage us to get it working before we release again.
---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c29ff6c5d8..2c79588016 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.8-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip

From 33e9d7751a0abca1829c5e7bca5e75e6d182b7c6 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:30:39 -0800
Subject: [PATCH 216/441] Update gradle.properties

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index d7a4f05753..d5f100c1d3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.16.1-SNAPSHOT
+version=0.16.2-SNAPSHOT

From 58c4a3d3d2e83bd39fbe989746e83ad07cd46363 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:31:01 -0800
Subject: [PATCH 217/441] 0.16.2-SNAPSHOT


From 5ec11c3529c79e3badbbee75f1e391af223a8b7a Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:36:48 -0800
Subject: [PATCH 218/441] Make Observable Methods Final

Their behavior is interrelated and co-dependent and should therefore not be over-written.
Observable itself is not made final as there are some limited reasons for inheritance (such as GroupedObservable and Subjects).
---
 ...rationObserveFromAndroidComponentTest.java | 114 ++-
 rxjava-core/src/main/java/rx/Observable.java  | 803 +++++++++---------
 .../rx/operators/OperationGroupByUntil.java   |  23 +-
 3 files changed, 486 insertions(+), 454 deletions(-)

diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
index 14ef2d2790..3aa84f8199 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
@@ -1,55 +1,54 @@
 /**
  * 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
- *
+ * 
+ * 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;
+package rx.android.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import static org.junit.Assert.*;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.operators.OperationObserveFromAndroidComponent;
+import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
+import rx.subscriptions.BooleanSubscription;
+import rx.util.functions.Action1;
 import android.app.Activity;
 import android.app.Fragment;
-import android.os.Looper;
-import android.util.Log;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
 
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
@@ -64,9 +63,6 @@ public class OperationObserveFromAndroidComponentTest {
     @Mock
     private Activity mockActivity;
 
-    @Mock
-    private Observable mockObservable;
-
     @Before
     public void setupMocks() {
         MockitoAnnotations.initMocks(this);
@@ -75,11 +71,12 @@ public void setupMocks() {
 
     @Test
     public void itThrowsIfObserverSubscribesFromBackgroundThread() throws Exception {
+        final Observable testObservable = Observable.from(1);
         final Future future = Executors.newSingleThreadExecutor().submit(new Callable() {
             @Override
             public Object call() throws Exception {
                 OperationObserveFromAndroidComponent.observeFromAndroidComponent(
-                        mockObservable, mockFragment).subscribe(mockObserver);
+                        testObservable, mockFragment).subscribe(mockObserver);
                 return null;
             }
         });
@@ -88,10 +85,44 @@ public Object call() throws Exception {
         verifyNoMoreInteractions(mockObserver);
     }
 
-    @Test
+    // TODO needs to be fixed, see comments inline below
+    @Ignore
     public void itObservesTheSourceSequenceOnTheMainUIThread() {
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(mockObservable, mockFragment).subscribe(mockObserver);
-        verify(mockObservable).observeOn(AndroidSchedulers.mainThread());
+        final Observable testObservable = Observable.from(1)
+                .observeOn(Schedulers.newThread())
+                .doOnNext(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        System.out.println("threadA: " + Thread.currentThread());
+                    }
+                })
+                .observeOn(AndroidSchedulers.mainThread())
+                .doOnNext(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        System.out.println("threadB: " + Thread.currentThread());
+                    }
+                });
+
+        final AtomicReference currentThreadName = new AtomicReference();
+        OperationObserveFromAndroidComponent.observeFromAndroidComponent(testObservable, mockFragment).subscribe(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                System.out.println("threadV: " + Thread.currentThread());
+                currentThreadName.set(Thread.currentThread().getName());
+            }
+        });
+
+        assertEquals("androidMainThreadName???", currentThreadName.get());
+
+        //TODO Can't use Mockito to validate Observable.observeOn as it is now marked as final.
+        //     I can't figure out what to validate about the AndroidSchedulers.mainThread()
+        //     as the code above doesn't print `threadB` so I can't see what Thread it should be.
+        //     I was going to run it on NewThread then observeOn to AndroidThread and validate it jumped
+        //     to the correct thread, but it doesn't do anything. Need to work with Android devs.
     }
 
     @Test
@@ -147,7 +178,7 @@ public void itDropsOnErrorIfTargetComponentIsGone() throws Throwable {
         verifyNoMoreInteractions(mockObserver);
     }
 
-    private Observable.OnSubscribeFunc newOnSubscribeFragmentInstance(Observable source, Fragment fragment) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException  {
+    private Observable.OnSubscribeFunc newOnSubscribeFragmentInstance(Observable source, Fragment fragment) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
         final Class[] klasses = OperationObserveFromAndroidComponent.class.getDeclaredClasses();
         Class onSubscribeFragmentClass = null;
         for (Class klass : klasses) {
@@ -200,14 +231,23 @@ public void itDoesNotForwardOnErrorIfFragmentIsDetached() {
 
     @Test
     public void itUnsubscribesFromTheSourceSequence() {
-        Subscription underlying = mock(Subscription.class);
-        when(mockObservable.observeOn(AndroidSchedulers.mainThread())).thenReturn(mockObservable);
-        when(mockObservable.subscribe(any(Observer.class))).thenReturn(underlying);
+        final BooleanSubscription s = new BooleanSubscription();
+        Observable testObservable = Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(Observer o) {
+                o.onNext(1);
+                o.onCompleted();
+                return s;
+            }
+
+        });
 
         Subscription sub = OperationObserveFromAndroidComponent.observeFromAndroidComponent(
-                mockObservable, mockActivity).subscribe(mockObserver);
+                testObservable, mockActivity).subscribe(mockObserver);
         sub.unsubscribe();
 
-        verify(underlying).unsubscribe();
+        assertTrue(s.isUnsubscribed());
     }
+
 }
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 365b49e083..1a47c0da69 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -199,7 +199,7 @@ protected Observable(OnSubscribeFunc onSubscribe) {
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Iterable> sources) {
+    public final static  Observable amb(Iterable> sources) {
         return create(OperationAmb.amb(sources));
     }
 
@@ -217,7 +217,7 @@ public static  Observable amb(Iterable>
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2) {
+    public final static  Observable amb(Observable o1, Observable o2) {
         return create(OperationAmb.amb(o1, o2));
     }
 
@@ -237,7 +237,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3) {
         return create(OperationAmb.amb(o1, o2, o3));
     }
 
@@ -259,7 +259,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4) {
         return create(OperationAmb.amb(o1, o2, o3, o4));
     }
 
@@ -283,7 +283,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) {
         return create(OperationAmb.amb(o1, o2, o3, o4, o5));
     }
 
@@ -309,7 +309,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) {
         return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6));
     }
 
@@ -337,7 +337,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) {
         return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7));
     }
 
@@ -367,7 +367,7 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) {
         return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
     }
 
@@ -399,12 +399,12 @@ public static  Observable amb(Observable o1, ObservableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
-    public static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) {
+    public final static  Observable amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) {
         return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
     }
 
     @Deprecated
-    public static Observable average(Observable source) {
+    public final static Observable average(Observable source) {
         return OperationAverage.average(source);
     }
 
@@ -421,7 +421,7 @@ public static Observable average(Observable source) {
      * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageDouble(Observable source) {
+    public final static Observable averageDouble(Observable source) {
         return OperationAverage.averageDoubles(source);
     }
 
@@ -438,7 +438,7 @@ public static Observable averageDouble(Observable source) {
      * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageFloat(Observable source) {
+    public final static Observable averageFloat(Observable source) {
         return OperationAverage.averageFloats(source);
     }
 
@@ -457,7 +457,7 @@ public static Observable averageFloat(Observable source) {
      * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageInteger(Observable source) {
+    public final static Observable averageInteger(Observable source) {
         return OperationAverage.average(source);
     }
 
@@ -474,7 +474,7 @@ public static Observable averageInteger(Observable source) {
      * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
-    public static Observable averageLong(Observable source) {
+    public final static Observable averageLong(Observable source) {
         return OperationAverage.averageLongs(source);
     }
 
@@ -498,7 +498,7 @@ public static Observable averageLong(Observable source) {
      *         function
      * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) {
+    public final static  Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) {
         return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction));
     }
 
@@ -524,7 +524,7 @@ public static  Observable combineLatest(Observable o
      *         function
      * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) {
+    public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) {
         return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction));
     }
 
@@ -552,7 +552,7 @@ public static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4,
+    public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4,
             Func4 combineFunction) {
         return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction));
     }
@@ -583,7 +583,7 @@ public static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5,
+    public final 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));
     }
@@ -616,7 +616,7 @@ public static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6,
+    public final 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));
     }
@@ -651,7 +651,7 @@ public static  Observable combineLatest(Observable
      *         function
      * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7,
+    public final 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));
     }
@@ -688,7 +688,7 @@ public static  Observable combineLatest(Observ
      *         function
      * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
+    public final 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));
     }
@@ -727,7 +727,8 @@ public static  Observable combineLatest(Ob
      *         function
      * @see RxJava Wiki: combineLatest()
      */
-    public static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9,
+    public final 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));
     }
@@ -746,7 +747,7 @@ public static  Observable combineLates
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
-    public static  Observable concat(Observable> observables) {
+    public final static  Observable concat(Observable> observables) {
         return create(OperationConcat.concat(observables));
     }
 
@@ -768,7 +769,7 @@ public static  Observable concat(Observable Observable concat(Observable t1, Observable t2) {
+    public final static  Observable concat(Observable t1, Observable t2) {
         return create(OperationConcat.concat(t1, t2));
     }
 
@@ -792,7 +793,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3) {
+    public final static  Observable concat(Observable t1, Observable t2, Observable t3) {
         return create(OperationConcat.concat(t1, t2, t3));
     }
 
@@ -818,7 +819,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4) {
+    public final static  Observable concat(Observable t1, Observable t2, Observable t3, Observable t4) {
         return create(OperationConcat.concat(t1, t2, t3, t4));
     }
 
@@ -846,7 +847,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
+    public final static  Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
         return create(OperationConcat.concat(t1, t2, t3, t4, t5));
     }
 
@@ -876,7 +877,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
+    public final 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));
     }
 
@@ -908,7 +909,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
+    public final 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));
     }
 
@@ -942,7 +943,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
+    public final 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));
     }
 
@@ -978,7 +979,7 @@ public static  Observable concat(Observable t1, Observable Observable concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) {
+    public final 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));
     }
 
@@ -1007,7 +1008,7 @@ public static  Observable concat(Observable t1, ObservableRxJava Wiki: create()
      * @see MSDN: Observable.Create
      */
-    public static  Observable create(OnSubscribeFunc func) {
+    public final static  Observable create(OnSubscribeFunc func) {
         return new Observable(func);
     }
 
@@ -1033,7 +1034,7 @@ public static  Observable create(OnSubscribeFunc func) {
      *         the given Observable factory function
      * @see RxJava Wiki: defer()
      */
-    public static  Observable defer(Func0> observableFactory) {
+    public final static  Observable defer(Func0> observableFactory) {
         return create(OperationDefer.defer(observableFactory));
     }
 
@@ -1050,7 +1051,7 @@ public static  Observable defer(Func0> o
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty
      */
-    public static  Observable empty() {
+    public final static  Observable empty() {
         return from(new ArrayList());
     }
 
@@ -1071,7 +1072,7 @@ public static  Observable empty() {
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty Method (IScheduler)
      */
-    public static  Observable empty(Scheduler scheduler) {
+    public final static  Observable empty(Scheduler scheduler) {
         return Observable. empty().subscribeOn(scheduler);
     }
 
@@ -1090,7 +1091,7 @@ public static  Observable empty(Scheduler scheduler) {
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
      */
-    public static  Observable error(Throwable exception) {
+    public final static  Observable error(Throwable exception) {
         return new ThrowObservable(exception);
     }
 
@@ -1110,7 +1111,7 @@ public static  Observable error(Throwable exception) {
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
      */
-    public static  Observable error(Throwable exception, Scheduler scheduler) {
+    public final static  Observable error(Throwable exception, Scheduler scheduler) {
         return Observable. error(exception).subscribeOn(scheduler);
     }
 
@@ -1133,7 +1134,7 @@ public static  Observable error(Throwable exception, Scheduler scheduler)
      * @return an Observable that emits the item from the source Future
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(Future future) {
+    public final static  Observable from(Future future) {
         return create(OperationToObservableFuture.toObservableFuture(future));
     }
 
@@ -1161,7 +1162,7 @@ public static  Observable from(Future future) {
      * @return an Observable that emits the item from the source {@link Future}
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(Future future, long timeout, TimeUnit unit) {
+    public final static  Observable from(Future future, long timeout, TimeUnit unit) {
         return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
@@ -1185,7 +1186,7 @@ public static  Observable from(Future future, long timeout, T
      * @return an Observable that emits the item from the source Future
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(Future future, Scheduler scheduler) {
+    public final static  Observable from(Future future, Scheduler scheduler) {
         return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
 
@@ -1206,7 +1207,7 @@ public static  Observable from(Future future, Scheduler sched
      * @return an Observable that emits each item in the source {@link Iterable} sequence
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(Iterable iterable) {
+    public final static  Observable from(Iterable iterable) {
         return from(iterable, Schedulers.immediate());
     }
 
@@ -1227,7 +1228,7 @@ public static  Observable from(Iterable iterable) {
      * @see RxJava Wiki: from()
      * @see MSDN: Observable.ToObservable
      */
-    public static  Observable from(Iterable iterable, Scheduler scheduler) {
+    public final static  Observable from(Iterable iterable, Scheduler scheduler) {
         return create(OperationToObservableIterable.toObservableIterable(iterable, scheduler));
     }
 
@@ -1250,7 +1251,7 @@ public static  Observable from(Iterable iterable, Scheduler s
      */
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
-    public static  Observable from(T t1) {
+    public final static  Observable from(T t1) {
         return from(Arrays.asList(t1));
     }
 
@@ -1277,7 +1278,7 @@ public static  Observable from(T t1) {
     @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
-    public static  Observable from(T t1, T t2) {
+    public final static  Observable from(T t1, T t2) {
         return from(Arrays.asList(t1, t2));
     }
 
@@ -1306,7 +1307,7 @@ public static  Observable from(T t1, T t2) {
     @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
-    public static  Observable from(T t1, T t2, T t3) {
+    public final static  Observable from(T t1, T t2, T t3) {
         return from(Arrays.asList(t1, t2, t3));
     }
 
@@ -1337,7 +1338,7 @@ public static  Observable from(T t1, T t2, T t3) {
     @Deprecated
     @SuppressWarnings("unchecked")
     // suppress unchecked because we are using varargs inside the method
-    public static  Observable from(T t1, T t2, T t3, T t4) {
+    public final static  Observable from(T t1, T t2, T t3, T t4) {
         return from(Arrays.asList(t1, t2, t3, t4));
     }
 
@@ -1370,7 +1371,7 @@ public static  Observable from(T t1, T t2, T t3, T t4) {
     @Deprecated
     @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) {
+    public final static  Observable from(T t1, T t2, T t3, T t4, T t5) {
         return from(Arrays.asList(t1, t2, t3, t4, t5));
     }
 
@@ -1405,7 +1406,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5) {
     @Deprecated
     @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) {
+    public final 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));
     }
 
@@ -1442,7 +1443,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6) {
     @Deprecated
     @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) {
+    public final 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));
     }
 
@@ -1481,7 +1482,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
     @Deprecated
     @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) {
+    public final 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));
     }
 
@@ -1522,7 +1523,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     @Deprecated
     @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) {
+    public final 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));
     }
 
@@ -1562,7 +1563,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     @Deprecated
     @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) {
+    public final 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));
     }
 
@@ -1582,7 +1583,7 @@ public static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * @return an Observable that emits each item in the source Array
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(T[] items) {
+    public final static  Observable from(T[] items) {
         return from(Arrays.asList(items));
     }
 
@@ -1604,7 +1605,7 @@ public static  Observable from(T[] items) {
      * @return an Observable that emits each item in the source Array
      * @see RxJava Wiki: from()
      */
-    public static  Observable from(T[] items, Scheduler scheduler) {
+    public final static  Observable from(T[] items, Scheduler scheduler) {
         return from(Arrays.asList(items), scheduler);
     }
 
@@ -1622,7 +1623,7 @@ public static  Observable from(T[] items, Scheduler scheduler) {
      * @see RxJava Wiki: interval()
      * @see MSDN: Observable.Interval
      */
-    public static Observable interval(long interval, TimeUnit unit) {
+    public final static Observable interval(long interval, TimeUnit unit) {
         return create(OperationInterval.interval(interval, unit));
     }
 
@@ -1642,7 +1643,7 @@ public static Observable interval(long interval, TimeUnit unit) {
      * @see RxJava Wiki: interval()
      * @see MSDN: Observable.Interval
      */
-    public static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) {
+    public final static Observable interval(long interval, TimeUnit unit, Scheduler scheduler) {
         return create(OperationInterval.interval(interval, unit, scheduler));
     }
 
@@ -1669,7 +1670,7 @@ public static Observable interval(long interval, TimeUnit unit, Scheduler
      * @deprecated Use {@link #from(T)}
      */
     @Deprecated
-    public static  Observable just(T value) {
+    public final static  Observable just(T value) {
         return from(Arrays.asList((value)));
     }
 
@@ -1693,7 +1694,7 @@ public static  Observable just(T value) {
      * @deprecated Use {@link #from(T)}
      */
     @Deprecated
-    public static  Observable just(T value, Scheduler scheduler) {
+    public final static  Observable just(T value, Scheduler scheduler) {
         return from(Arrays.asList((value)), scheduler);
     }
 
@@ -1712,7 +1713,7 @@ public static  Observable just(T value, Scheduler scheduler) {
      * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
-    public static > Observable max(Observable source) {
+    public final static > Observable max(Observable source) {
         return OperationMinMax.max(source);
     }
 
@@ -1731,7 +1732,7 @@ public static > Observable max(Observable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Iterable> sequences) {
+    public final static  Observable merge(Iterable> sequences) {
         return merge(from(sequences));
     }
 
@@ -1754,7 +1755,7 @@ public static  Observable merge(Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Iterable> sequences, int maxConcurrent) {
+    public final static  Observable merge(Iterable> sequences, int maxConcurrent) {
         return merge(from(sequences), maxConcurrent);
     }
 
@@ -1779,7 +1780,7 @@ public static  Observable merge(Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Iterable> sequences, int maxConcurrent, Scheduler scheduler) {
+    public final static  Observable merge(Iterable> sequences, int maxConcurrent, Scheduler scheduler) {
         return merge(from(sequences, scheduler), maxConcurrent);
     }
 
@@ -1800,7 +1801,7 @@ public static  Observable merge(Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Iterable> sequences, Scheduler scheduler) {
+    public final static  Observable merge(Iterable> sequences, Scheduler scheduler) {
         return merge(from(sequences, scheduler));
     }
 
@@ -1820,7 +1821,7 @@ public static  Observable merge(Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable> source) {
+    public final static  Observable merge(Observable> source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -1843,7 +1844,7 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable> source, int maxConcurrent) {
+    public final static  Observable merge(Observable> source, int maxConcurrent) {
         return create(OperationMerge.merge(source, maxConcurrent));
     }
 
@@ -1865,7 +1866,7 @@ public static  Observable merge(ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2) {
+    public final static  Observable merge(Observable t1, Observable t2) {
         return merge(from(t1, t2));
     }
 
@@ -1889,7 +1890,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3) {
         return merge(from(t1, t2, t3));
     }
 
@@ -1915,7 +1916,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) {
         return merge(from(t1, t2, t3, t4));
     }
 
@@ -1943,7 +1944,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
         return merge(from(t1, t2, t3, t4, t5));
     }
 
@@ -1973,7 +1974,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
         return merge(from(t1, t2, t3, t4, t5, t6));
     }
 
@@ -2005,7 +2006,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
         return merge(from(t1, t2, t3, t4, t5, t6, t7));
     }
 
@@ -2039,7 +2040,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
         return merge(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
 
@@ -2076,7 +2077,7 @@ public static  Observable merge(Observable t1, ObservableMSDN: Observable.Merge
      */
     // 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) {
+    public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) {
         return merge(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
 
@@ -2095,7 +2096,7 @@ public static  Observable merge(Observable t1, ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable[] sequences) {
+    public final static  Observable merge(Observable[] sequences) {
         return merge(from(sequences));
     }
 
@@ -2116,7 +2117,7 @@ public static  Observable merge(Observable[] sequences) {
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable merge(Observable[] sequences, Scheduler scheduler) {
+    public final static  Observable merge(Observable[] sequences, Scheduler scheduler) {
         return merge(from(sequences, scheduler));
     }
 
@@ -2142,7 +2143,7 @@ public static  Observable merge(Observable[] sequences, Sched
      * @see RxJava Wiki: mergeDelayError()
      * @see MSDN: Observable.Merge
      */
-    public static  Observable mergeDelayError(Observable> source) {
+    public final static  Observable mergeDelayError(Observable> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -2172,7 +2173,7 @@ public static  Observable mergeDelayError(Observable Observable mergeDelayError(Observable t1, Observable t2) {
+    public final static  Observable mergeDelayError(Observable t1, Observable t2) {
         return create(OperationMergeDelayError.mergeDelayError(t1, t2));
     }
 
@@ -2204,7 +2205,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final static  Observable mergeDelayError(Observable t1, Observable t2, Observable t3) {
         return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3));
     }
 
@@ -2238,7 +2239,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final static  Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4) {
         return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4));
     }
 
@@ -2274,7 +2275,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final static  Observable mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
         return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5));
     }
 
@@ -2312,7 +2313,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final 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));
     }
 
@@ -2352,7 +2353,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final 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));
     }
 
@@ -2394,7 +2395,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final 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));
     }
 
@@ -2438,7 +2439,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      */
     @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) {
+    public final 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));
     }
 
@@ -2457,7 +2458,7 @@ public static  Observable mergeDelayError(Observable t1, Obse
      *             if the source is empty
      * @see MSDN: Observable.Min
      */
-    public static > Observable min(Observable source) {
+    public final static > Observable min(Observable source) {
         return OperationMinMax.min(source);
     }
 
@@ -2474,7 +2475,7 @@ public static > Observable min(Observable
      *         notifications to an {@link Observer}
      * @see RxJava Wiki: never()
      */
-    public static  Observable never() {
+    public final static  Observable never() {
         return new NeverObservable();
     }
 
@@ -2500,7 +2501,7 @@ public static  Observable never() {
      *         parallelObservables
      * @see RxJava Wiki: parallelMerge()
      */
-    public static  Observable> parallelMerge(Observable> source, int parallelObservables) {
+    public final static  Observable> parallelMerge(Observable> source, int parallelObservables) {
         return OperationParallelMerge.parallelMerge(source, parallelObservables);
     }
 
@@ -2529,7 +2530,7 @@ public static  Observable> parallelMerge(ObservableparallelObservables
      * @see RxJava Wiki: parallelMerge()
      */
-    public static  Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) {
+    public final static  Observable> parallelMerge(Observable> source, int parallelObservables, Scheduler scheduler) {
         return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
     }
 
@@ -2548,7 +2549,7 @@ public static  Observable> parallelMerge(ObservableRxJava Wiki: range()
      * @see MSDN: Observable.Range
      */
-    public static Observable range(int start, int count) {
+    public final static Observable range(int start, int count) {
         return from(Range.createWithCount(start, count));
     }
 
@@ -2568,7 +2569,7 @@ public static Observable range(int start, int count) {
      * @see RxJava Wiki: range()
      * @see MSDN: Observable.Range
      */
-    public static Observable range(int start, int count, Scheduler scheduler) {
+    public final static Observable range(int start, int count, Scheduler scheduler) {
         return from(Range.createWithCount(start, count), scheduler);
     }
 
@@ -2589,10 +2590,10 @@ public static Observable range(int start, int count, Scheduler schedule
      *         two sequences are equal by comparing the elements pairwise
      * @see RxJava Wiki: sequenceEqual()
      */
-    public static  Observable sequenceEqual(Observable first, Observable second) {
+    public final static  Observable sequenceEqual(Observable first, Observable second) {
         return sequenceEqual(first, second, new Func2() {
             @Override
-            public Boolean call(T first, T second) {
+            public final Boolean call(T first, T second) {
                 if (first == null) {
                     return second == null;
                 }
@@ -2622,12 +2623,12 @@ public Boolean call(T first, T second) {
      *         two sequences are equal by comparing the elements pairwise
      * @see RxJava Wiki: sequenceEqual()
      */
-    public static  Observable sequenceEqual(Observable first, Observable second, Func2 equality) {
+    public final static  Observable sequenceEqual(Observable first, Observable second, Func2 equality) {
         return OperationSequenceEqual.sequenceEqual(first, second, equality);
     }
 
     @Deprecated
-    public static Observable sum(Observable source) {
+    public final static Observable sum(Observable source) {
         return OperationSum.sum(source);
     }
 
@@ -2644,7 +2645,7 @@ public static Observable sum(Observable source) {
      * @see RxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumDouble(Observable source) {
+    public final static Observable sumDouble(Observable source) {
         return OperationSum.sumDoubles(source);
     }
 
@@ -2661,7 +2662,7 @@ public static Observable sumDouble(Observable source) {
      * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumFloat(Observable source) {
+    public final static Observable sumFloat(Observable source) {
         return OperationSum.sumFloats(source);
     }
 
@@ -2678,7 +2679,7 @@ public static Observable sumFloat(Observable source) {
      * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumInteger(Observable source) {
+    public final static Observable sumInteger(Observable source) {
         return OperationSum.sum(source);
     }
 
@@ -2695,7 +2696,7 @@ public static Observable sumInteger(Observable source) {
      * @see RxJava Wiki: sumLong()
      * @see MSDN: Observable.Sum
      */
-    public static Observable sumLong(Observable source) {
+    public final static Observable sumLong(Observable source) {
         return OperationSum.sumLongs(source);
     }
 
@@ -2714,7 +2715,7 @@ public static Observable sumLong(Observable source) {
      * @deprecated use {@link #switchOnNext}
      */
     @Deprecated
-    public static  Observable switchDo(Observable> sequenceOfSequences) {
+    public final static  Observable switchDo(Observable> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
@@ -2732,7 +2733,7 @@ public static  Observable switchDo(ObservableRxJava Wiki: switchOnNext()
      * @see {@link #switchOnNext(Observable)}
      */
-    public static  Observable switchLatest(Observable> sequenceOfSequences) {
+    public final static  Observable switchLatest(Observable> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
@@ -2749,7 +2750,7 @@ public static  Observable switchLatest(ObservableRxJava Wiki: switchOnNext()
      */
-    public static  Observable switchOnNext(Observable> sequenceOfSequences) {
+    public final static  Observable switchOnNext(Observable> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
@@ -2757,7 +2758,7 @@ public static  Observable switchOnNext(Observable Observable synchronize(Observable source) {
+    public final static  Observable synchronize(Observable source) {
         return create(OperationSynchronize.synchronize(source));
     }
 
@@ -2780,7 +2781,7 @@ public static  Observable synchronize(Observable source) {
      * @see RxJava Wiki: timer()
      * @see MSDN: Observable.Timer
      */
-    public static Observable timer(long initialDelay, long period, TimeUnit unit) {
+    public final static Observable timer(long initialDelay, long period, TimeUnit unit) {
         return timer(initialDelay, period, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -2808,7 +2809,7 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
      * @see RxJava Wiki: timer()
      * @see MSDN: Observable.Timer
      */
-    public static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
+    public final static Observable timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler));
     }
 
@@ -2824,7 +2825,7 @@ public static Observable timer(long initialDelay, long period, TimeUnit un
      *            time units to use for the interval size
      * @see RxJava wiki: timer()
      */
-    public static Observable timer(long delay, TimeUnit unit) {
+    public final static Observable timer(long delay, TimeUnit unit) {
         return timer(delay, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -2842,7 +2843,7 @@ public static Observable timer(long delay, TimeUnit unit) {
      *            the scheduler to use for scheduling the item
      * @see RxJava wiki: timer()
      */
-    public static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
+    public final static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTimer.TimerOnce(delay, unit, scheduler));
     }
 
@@ -2861,7 +2862,7 @@ public static Observable timer(long delay, TimeUnit unit, Scheduler schedu
      * @see RxJava Wiki: using()
      * @see MSDN: Observable.Using
      */
-    public static  Observable using(Func0 resourceFactory, Func1> observableFactory) {
+    public final static  Observable using(Func0 resourceFactory, Func1> observableFactory) {
         return create(OperationUsing.using(resourceFactory, observableFactory));
     }
 
@@ -2879,7 +2880,7 @@ public static  Observable using(Func0RxJava Wiki: when()
      * @see MSDN: Observable.When
      */
-    public static  Observable when(Iterable> plans) {
+    public final static  Observable when(Iterable> plans) {
         if (plans == null) {
             throw new NullPointerException("plans");
         }
@@ -2900,7 +2901,7 @@ public static  Observable when(Iterable> plans) {
      * @see RxJava Wiki: when()
      * @see MSDN: Observable.When
      */
-    public static  Observable when(Plan0... plans) {
+    public final static  Observable when(Plan0... plans) {
         return create(OperationJoinPatterns.when(plans));
     }
 
@@ -2916,7 +2917,7 @@ public static  Observable when(Plan0... plans) {
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1) {
+    public final static  Observable when(Plan0 p1) {
         return create(OperationJoinPatterns.when(p1));
     }
 
@@ -2935,7 +2936,7 @@ public static  Observable when(Plan0 p1) {
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2) {
+    public final static  Observable when(Plan0 p1, Plan0 p2) {
         return create(OperationJoinPatterns.when(p1, p2));
     }
 
@@ -2956,7 +2957,7 @@ public static  Observable when(Plan0 p1, Plan0 p2) {
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
         return create(OperationJoinPatterns.when(p1, p2, p3));
     }
 
@@ -2979,7 +2980,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3) {
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4));
     }
 
@@ -3004,7 +3005,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5));
     }
 
@@ -3031,7 +3032,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6));
     }
 
@@ -3060,7 +3061,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7));
     }
 
@@ -3091,7 +3092,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8));
     }
 
@@ -3124,7 +3125,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @see MSDN: Observable.When
      */
     @SuppressWarnings("unchecked")
-    public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8, Plan0 p9) {
+    public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan0 p4, Plan0 p5, Plan0 p6, Plan0 p7, Plan0 p8, Plan0 p9) {
         return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9));
     }
 
@@ -3153,7 +3154,7 @@ public static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3, Plan
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Iterable> ws, FuncN zipFunction) {
+    public final static  Observable zip(Iterable> ws, FuncN zipFunction) {
         return create(OperationZip.zip(ws, zipFunction));
     }
 
@@ -3182,10 +3183,10 @@ public static  Observable zip(Iterable> ws, FuncN<
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable> ws, final FuncN zipFunction) {
+    public final static  Observable zip(Observable> ws, final FuncN zipFunction) {
         return ws.toList().mergeMap(new Func1>, Observable>() {
             @Override
-            public Observable call(List> wsList) {
+            public final Observable call(List> wsList) {
                 return create(OperationZip.zip(wsList, zipFunction));
             }
         });
@@ -3217,7 +3218,7 @@ public Observable call(List> wsList) {
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Func2 zipFunction) {
+    public final static  Observable zip(Observable o1, Observable o2, Func2 zipFunction) {
         return create(OperationZip.zip(o1, o2, zipFunction));
     }
 
@@ -3250,7 +3251,7 @@ public static  Observable zip(Observable o1, Observa
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Func3 zipFunction) {
+    public final static  Observable zip(Observable o1, Observable o2, Observable o3, Func3 zipFunction) {
         return create(OperationZip.zip(o1, o2, o3, zipFunction));
     }
 
@@ -3286,7 +3287,7 @@ public static  Observable zip(Observable o1, Obs
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Func4 zipFunction) {
+    public final static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Func4 zipFunction) {
         return create(OperationZip.zip(o1, o2, o3, o4, zipFunction));
     }
 
@@ -3324,7 +3325,7 @@ public static  Observable zip(Observable o1,
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 zipFunction) {
+    public final 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));
     }
 
@@ -3363,7 +3364,7 @@ public static  Observable zip(Observable
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6,
+    public final 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));
     }
@@ -3405,7 +3406,7 @@ public static  Observable zip(ObservableRxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7,
+    public final 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));
     }
@@ -3449,7 +3450,7 @@ public static  Observable zip(ObservableRxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
+    public final 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));
     }
@@ -3495,7 +3496,7 @@ public static  Observable zip(ObservableRxJava Wiki: zip()
      */
-    public static  Observable zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
+    public final 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));
     }
@@ -3510,7 +3511,7 @@ public static  Observable zip(Observab
      * @deprecated use #reduce(Func2)
      */
     @Deprecated
-    public Observable aggregate(Func2 accumulator) {
+    public final Observable aggregate(Func2 accumulator) {
         return reduce(accumulator);
     }
 
@@ -3524,7 +3525,7 @@ public Observable aggregate(Func2 accumulator) {
      * @deprecated use #reduce(Object, Func2)
      */
     @Deprecated
-    public  Observable aggregate(R initialValue, Func2 accumulator) {
+    public final  Observable aggregate(R initialValue, Func2 accumulator) {
         return reduce(initialValue, accumulator);
     }
 
@@ -3541,7 +3542,7 @@ public  Observable aggregate(R initialValue, Func2 accumu
      *         false
      * @see RxJava Wiki: all()
      */
-    public Observable all(Func1 predicate) {
+    public final Observable all(Func1 predicate) {
         return create(OperationAll.all(this, predicate));
     }
 
@@ -3558,7 +3559,7 @@ public Observable all(Func1 predicate) {
      * @see RxJava Wiki: and()
      * @see MSDN: Observable.And
      */
-    public  Pattern2 and(Observable right) {
+    public final  Pattern2 and(Observable right) {
         return OperationJoinPatterns.and(this, right);
     }
 
@@ -3567,7 +3568,7 @@ public  Pattern2 and(Observable right) {
      * 
      * @return an Observable hiding the identity of this Observable.
      */
-    public Observable asObservable() {
+    public final Observable asObservable() {
         return create(new OperationAsObservable(this));
     }
 
@@ -3587,7 +3588,7 @@ public Observable asObservable() {
      * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
-    public Observable averageDouble(Func1 valueExtractor) {
+    public final Observable averageDouble(Func1 valueExtractor) {
         return create(new OperationAverage.AverageDoubleExtractor(this, valueExtractor));
     }
 
@@ -3607,7 +3608,7 @@ public Observable averageDouble(Func1 valueExtractor)
      * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
-    public Observable averageFloat(Func1 valueExtractor) {
+    public final Observable averageFloat(Func1 valueExtractor) {
         return create(new OperationAverage.AverageFloatExtractor(this, valueExtractor));
     }
 
@@ -3627,7 +3628,7 @@ public Observable averageFloat(Func1 valueExtractor) {
      * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
-    public Observable averageInteger(Func1 valueExtractor) {
+    public final Observable averageInteger(Func1 valueExtractor) {
         return create(new OperationAverage.AverageIntegerExtractor(this, valueExtractor));
     }
 
@@ -3647,7 +3648,7 @@ public Observable averageInteger(Func1 valueExtract
      * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
-    public Observable averageLong(Func1 valueExtractor) {
+    public final Observable averageLong(Func1 valueExtractor) {
         return create(new OperationAverage.AverageLongExtractor(this, valueExtractor));
     }
 
@@ -3673,7 +3674,7 @@ public Observable averageLong(Func1 valueExtractor) {
      *         buffers when the current {@link Observable} created with the {@code bufferClosingSelector} argument emits an item
      * @see RxJava Wiki: buffer()
      */
-    public  Observable> buffer(Func0> bufferClosingSelector) {
+    public final  Observable> buffer(Func0> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferClosingSelector));
     }
 
@@ -3695,7 +3696,7 @@ public  Observable> buffer(Func0RxJava Wiki: buffer()
      */
-    public Observable> buffer(int count) {
+    public final Observable> buffer(int count) {
         return create(OperationBuffer.buffer(this, count));
     }
 
@@ -3719,7 +3720,7 @@ public Observable> buffer(int count) {
      *         item and containing at most count items
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(int count, int skip) {
+    public final Observable> buffer(int count, int skip) {
         return create(OperationBuffer.buffer(this, count, skip));
     }
 
@@ -3748,7 +3749,7 @@ public Observable> buffer(int count, int skip) {
      *         elapsed
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, long timeshift, TimeUnit unit) {
+    public final Observable> buffer(long timespan, long timeshift, TimeUnit unit) {
         return create(OperationBuffer.buffer(this, timespan, timeshift, unit));
     }
 
@@ -3780,7 +3781,7 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit)
      *         elapsed
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
     }
 
@@ -3804,7 +3805,7 @@ public Observable> buffer(long timespan, long timeshift, TimeUnit unit,
      *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit) {
+    public final Observable> buffer(long timespan, TimeUnit unit) {
         return create(OperationBuffer.buffer(this, timespan, unit));
     }
 
@@ -3834,7 +3835,7 @@ public Observable> buffer(long timespan, TimeUnit unit) {
      *         (whichever occurs first)
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit, int count) {
+    public final Observable> buffer(long timespan, TimeUnit unit, int count) {
         return create(OperationBuffer.buffer(this, timespan, unit, count));
     }
 
@@ -3867,7 +3868,7 @@ public Observable> buffer(long timespan, TimeUnit unit, int count) {
      *         occurs first)
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+    public final Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
         return create(OperationBuffer.buffer(this, timespan, unit, count, scheduler));
     }
 
@@ -3894,7 +3895,7 @@ public Observable> buffer(long timespan, TimeUnit unit, int count, Sched
      *         buffers with a fixed duration
      * @see RxJava Wiki: buffer()
      */
-    public Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
         return create(OperationBuffer.buffer(this, timespan, unit, scheduler));
     }
 
@@ -3919,7 +3920,7 @@ public Observable> buffer(long timespan, TimeUnit unit, Scheduler schedu
      *         closed when the specified {@link Observable}s emit items
      * @see RxJava Wiki: buffer()
      */
-    public  Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) {
+    public final  Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
@@ -3936,7 +3937,7 @@ public  Observable> buffer(Observable Observable> buffer(Observable boundary) {
+    public final  Observable> buffer(Observable boundary) {
         return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
     }
 
@@ -3955,7 +3956,7 @@ public  Observable> buffer(Observable boundary) {
      * @return an Observable that emits buffered items once the boundary observable emits an item.
      * @see #buffer(rx.Observable, int)
      */
-    public  Observable> buffer(Observable boundary, int initialCapacity) {
+    public final  Observable> buffer(Observable boundary, int initialCapacity) {
         return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
     }
 
@@ -3981,7 +3982,7 @@ public  Observable> buffer(Observable boundary, int initialCapacit
      *         items and notifications for the benefit of subsequent observers
      * @see RxJava Wiki: cache()
      */
-    public Observable cache() {
+    public final Observable cache() {
         return create(OperationCache.cache(this));
     }
 
@@ -3997,7 +3998,7 @@ public Observable cache() {
      * @see RxJava Wiki: cast()
      * @see MSDN: Observable.Cast
      */
-    public  Observable cast(final Class klass) {
+    public final  Observable cast(final Class klass) {
         return create(OperationCast.cast(this, klass));
     }
 
@@ -4011,11 +4012,11 @@ public  Observable cast(final Class klass) {
      * @param collector
      * @return
      */
-    public  Observable collect(R state, final Action2 collector) {
+    public final  Observable collect(R state, final Action2 collector) {
         Func2 accumulator = new Func2() {
 
             @Override
-            public R call(R state, T value) {
+            public final R call(R state, T value) {
                 collector.call(state, value);
                 return state;
             }
@@ -4040,7 +4041,7 @@ public R call(R state, T value) {
      *         Observable and concatting the results of the Observables obtained
      *         from this transformation.
      */
-    public  Observable concatMap(Func1> func) {
+    public final  Observable concatMap(Func1> func) {
         return concat(map(func));
     }
 
@@ -4059,9 +4060,9 @@ public  Observable concatMap(Func1RxJava Wiki: contains()
      * @see MSDN: Observable.Contains
      */
-    public Observable contains(final T element) {
+    public final Observable contains(final T element) {
         return exists(new Func1() {
-            public Boolean call(T t1) {
+            public final Boolean call(T t1) {
                 return element == null ? t1 == null : element.equals(t1);
             }
         });
@@ -4079,10 +4080,10 @@ public Boolean call(T t1) {
      * @see MSDN: Observable.Count
      * @see #longCount()
      */
-    public Observable count() {
+    public final Observable count() {
         return reduce(0, new Func2() {
             @Override
-            public Integer call(Integer t1, T t2) {
+            public final Integer call(Integer t1, T t2) {
                 return t1 + 1;
             }
         });
@@ -4101,7 +4102,7 @@ public Integer call(Integer t1, T t2) {
      *         sequence which are followed by another value within a computed
      *         debounce duration
      */
-    public  Observable debounce(Func1> debounceSelector) {
+    public final  Observable debounce(Func1> debounceSelector) {
         return create(OperationDebounce.debounceSelector(this, debounceSelector));
     }
 
@@ -4133,7 +4134,7 @@ public  Observable debounce(Func1> debo
      * @see RxJava Wiki: debounce()
      * @see #throttleWithTimeout(long, TimeUnit)
      */
-    public Observable debounce(long timeout, TimeUnit unit) {
+    public final Observable debounce(long timeout, TimeUnit unit) {
         return create(OperationDebounce.debounce(this, timeout, unit));
     }
 
@@ -4168,7 +4169,7 @@ public Observable debounce(long timeout, TimeUnit unit) {
      * @see RxJava Wiki: debounce()
      * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
      */
-    public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
+    public final Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
         return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
     }
 
@@ -4187,7 +4188,7 @@ public Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler)
      * @see RxJava Wiki: defaultIfEmpty()
      * @see MSDN: Observable.DefaultIfEmpty
      */
-    public Observable defaultIfEmpty(T defaultValue) {
+    public final Observable defaultIfEmpty(T defaultValue) {
         return create(OperationDefaultIfEmpty.defaultIfEmpty(this, defaultValue));
     }
 
@@ -4210,7 +4211,7 @@ public Observable defaultIfEmpty(T defaultValue) {
      *            fires its first onNext event.
      * @return an Observable which delays the events via another Observable on a per item-basis.
      */
-    public  Observable delay(
+    public final  Observable delay(
             Func0> subscriptionDelay,
             Func1> itemDelay) {
         return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
@@ -4229,7 +4230,7 @@ public  Observable delay(
      *            fires its first onNext event.
      * @return an Observable which delays the events via another Observable on a per item-basis.
      */
-    public  Observable delay(Func1> itemDelay) {
+    public final  Observable delay(Func1> itemDelay) {
         return create(OperationDelay.delay(this, itemDelay));
     }
 
@@ -4248,7 +4249,7 @@ public  Observable delay(Func1> itemDel
      * @see RxJava Wiki: delay()
      * @see MSDN: Observable.Delay
      */
-    public Observable delay(long delay, TimeUnit unit) {
+    public final Observable delay(long delay, TimeUnit unit) {
         return OperationDelay.delay(this, delay, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -4269,7 +4270,7 @@ public Observable delay(long delay, TimeUnit unit) {
      * @see RxJava Wiki: delay()
      * @see MSDN: Observable.Delay
      */
-    public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
+    public final Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
         return OperationDelay.delay(this, delay, unit, scheduler);
     }
 
@@ -4286,7 +4287,7 @@ public Observable delay(long delay, TimeUnit unit, Scheduler scheduler) {
      * @return an Observable that delays the subscription to the source
      *         Observable by the given amount
      */
-    public Observable delaySubscription(long delay, TimeUnit unit) {
+    public final Observable delaySubscription(long delay, TimeUnit unit) {
         return delaySubscription(delay, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -4308,7 +4309,7 @@ public Observable delaySubscription(long delay, TimeUnit unit) {
      *         Observable by a given amount, waiting and subscribing on the
      *         given Scheduler
      */
-    public Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
+    public final Observable delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(OperationDelay.delaySubscription(this, delay, unit, scheduler));
     }
 
@@ -4327,7 +4328,7 @@ public Observable delaySubscription(long delay, TimeUnit unit, Scheduler sche
      * @see MSDN: Observable.dematerialize
      */
     @SuppressWarnings("unchecked")
-    public  Observable dematerialize() {
+    public final  Observable dematerialize() {
         return create(OperationDematerialize.dematerialize((Observable>) this));
     }
 
@@ -4342,7 +4343,7 @@ public  Observable dematerialize() {
      * @see RxJava Wiki: distinct()
      * @see MSDN: Observable.distinct
      */
-    public Observable distinct() {
+    public final Observable distinct() {
         return create(OperationDistinct.distinct(this));
     }
 
@@ -4361,7 +4362,7 @@ public Observable distinct() {
      * @see RxJava Wiki: distinct()
      * @see MSDN: Observable.distinct
      */
-    public  Observable distinct(Func1 keySelector) {
+    public final  Observable distinct(Func1 keySelector) {
         return create(OperationDistinct.distinct(this, keySelector));
     }
 
@@ -4376,7 +4377,7 @@ public  Observable distinct(Func1 keySelector) {
      * @see RxJava Wiki: distinctUntilChanged()
      * @see MSDN: Observable.distinctUntilChanged
      */
-    public Observable distinctUntilChanged() {
+    public final Observable distinctUntilChanged() {
         return create(OperationDistinctUntilChanged.distinctUntilChanged(this));
     }
 
@@ -4396,7 +4397,7 @@ public Observable distinctUntilChanged() {
      * @see RxJava Wiki: distinctUntilChanged()
      * @see MSDN: Observable.distinctUntilChanged
      */
-    public  Observable distinctUntilChanged(Func1 keySelector) {
+    public final  Observable distinctUntilChanged(Func1 keySelector) {
         return create(OperationDistinctUntilChanged.distinctUntilChanged(this, keySelector));
     }
 
@@ -4413,19 +4414,19 @@ public  Observable distinctUntilChanged(Func1 keyS
      * @see RxJava Wiki: doOnCompleted()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnCompleted(final Action0 onCompleted) {
+    public final Observable doOnCompleted(final Action0 onCompleted) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 onCompleted.call();
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
             }
 
         };
@@ -4445,20 +4446,20 @@ public void onNext(T args) {
      * @see RxJava Wiki: doOnEach()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnEach(final Action1> onNotification) {
+    public final Observable doOnEach(final Action1> onNotification) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 onNotification.call(new Notification());
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 onNotification.call(new Notification(e));
             }
 
             @Override
-            public void onNext(T v) {
+            public final void onNext(T v) {
                 onNotification.call(new Notification(v));
             }
 
@@ -4479,7 +4480,7 @@ public void onNext(T v) {
      * @see RxJava Wiki: doOnEach()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnEach(Observer observer) {
+    public final Observable doOnEach(Observer observer) {
         return create(OperationDoOnEach.doOnEach(this, observer));
     }
 
@@ -4495,19 +4496,19 @@ public Observable doOnEach(Observer observer) {
      * @see RxJava Wiki: doOnError()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnError(final Action1 onError) {
+    public final Observable doOnError(final Action1 onError) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 onError.call(e);
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
             }
 
         };
@@ -4528,18 +4529,18 @@ public void onNext(T args) {
      * @see RxJava Wiki: doOnNext()
      * @see MSDN: Observable.Do
      */
-    public Observable doOnNext(final Action1 onNext) {
+    public final Observable doOnNext(final Action1 onNext) {
         Observer observer = new Observer() {
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
                 onNext.call(args);
             }
 
@@ -4566,7 +4567,7 @@ public void onNext(T args) {
      *             if index is less than 0
      * @see RxJava Wiki: elementAt()
      */
-    public Observable elementAt(int index) {
+    public final Observable elementAt(int index) {
         return create(OperationElementAt.elementAt(this, index));
     }
 
@@ -4587,7 +4588,7 @@ public Observable elementAt(int index) {
      *             if index is less than 0
      * @see RxJava Wiki: elementAtOrDefault()
      */
-    public Observable elementAtOrDefault(int index, T defaultValue) {
+    public final Observable elementAtOrDefault(int index, T defaultValue) {
         return create(OperationElementAt.elementAtOrDefault(this, index, defaultValue));
     }
 
@@ -4609,7 +4610,7 @@ public Observable elementAtOrDefault(int index, T defaultValue) {
      * @see RxJava Wiki: exists()
      * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
      */
-    public Observable exists(Func1 predicate) {
+    public final Observable exists(Func1 predicate) {
         return create(OperationAny.exists(this, predicate));
     }
 
@@ -4626,7 +4627,7 @@ public Observable exists(Func1 predicate) {
      *         Observable that the filter evaluates as {@code true}
      * @see RxJava Wiki: filter()
      */
-    public Observable filter(Func1 predicate) {
+    public final Observable filter(Func1 predicate) {
         return create(OperationFilter.filter(this, predicate));
     }
 
@@ -4643,7 +4644,7 @@ public Observable filter(Func1 predicate) {
      * @see RxJava Wiki: finallyDo()
      * @see MSDN: Observable.Finally
      */
-    public Observable finallyDo(Action0 action) {
+    public final Observable finallyDo(Action0 action) {
         return create(OperationFinally.finallyDo(this, action));
     }
 
@@ -4659,7 +4660,7 @@ public Observable finallyDo(Action0 action) {
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.firstAsync()
      */
-    public Observable first() {
+    public final Observable first() {
         return take(1).single();
     }
 
@@ -4677,7 +4678,7 @@ public Observable first() {
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.firstAsync()
      */
-    public Observable first(Func1 predicate) {
+    public final Observable first(Func1 predicate) {
         return takeFirst(predicate).single();
     }
 
@@ -4696,7 +4697,7 @@ public Observable first(Func1 predicate) {
      * @see RxJava Wiki: firstOrDefault()
      * @see MSDN: Observable.firstOrDefaultAsync()
      */
-    public Observable firstOrDefault(T defaultValue) {
+    public final Observable firstOrDefault(T defaultValue) {
         return take(1).singleOrDefault(defaultValue);
     }
 
@@ -4717,7 +4718,7 @@ public Observable firstOrDefault(T defaultValue) {
      * @see RxJava Wiki: firstOrDefault()
      * @see MSDN: Observable.firstOrDefaultAsync()
      */
-    public Observable firstOrDefault(T defaultValue, Func1 predicate) {
+    public final Observable firstOrDefault(T defaultValue, Func1 predicate) {
         return takeFirst(predicate).singleOrDefault(defaultValue);
     }
 
@@ -4741,7 +4742,7 @@ public Observable firstOrDefault(T defaultValue, Func1 pr
      * @see RxJava Wiki: flatMap()
      * @see #mapMany(Func1)
      */
-    public  Observable flatMap(Func1> func) {
+    public final  Observable flatMap(Func1> func) {
         return mergeMap(func);
     }
 
@@ -4762,7 +4763,7 @@ public  Observable flatMap(Func1RxJava Wiki: groupBy
      */
-    public  Observable> groupBy(final Func1 keySelector) {
+    public final  Observable> groupBy(final Func1 keySelector) {
         return create(OperationGroupBy.groupBy(this, keySelector));
     }
 
@@ -4787,7 +4788,7 @@ public  Observable> groupBy(final Func1RxJava Wiki: groupBy
      */
-    public  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
+    public final  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
         return create(OperationGroupBy.groupBy(this, keySelector, elementSelector));
     }
 
@@ -4807,7 +4808,7 @@ public  Observable> groupBy(final Func1RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
+    public final  Observable> groupByUntil(Func1 keySelector, Func1, ? extends Observable> durationSelector) {
         return groupByUntil(keySelector, Functions. identity(), durationSelector);
     }
 
@@ -4831,7 +4832,7 @@ public  Observable> groupByUntil(Fun
      * @see RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
-    public  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
+    public final  Observable> groupByUntil(Func1 keySelector, Func1 valueSelector, Func1, ? extends Observable> durationSelector) {
         return create(new OperationGroupByUntil(this, keySelector, valueSelector, durationSelector));
     }
 
@@ -4861,7 +4862,7 @@ public  Observable> gro
      * @see RxJava Wiiki: groupJoin
      * @see MSDN: Observable.GroupJoin
      */
-    public  Observable groupJoin(Observable right, Func1> leftDuration,
+    public final  Observable groupJoin(Observable right, Func1> leftDuration,
             Func1> rightDuration,
             Func2, ? extends R> resultSelector) {
         return create(new OperationGroupJoin(this, right, leftDuration, rightDuration, resultSelector));
@@ -4878,7 +4879,7 @@ public  Observable groupJoin(Observable right, Func1RxJava Wiki: ignoreElements()
      * @see MSDN: Observable.IgnoreElements
      */
-    public Observable ignoreElements() {
+    public final Observable ignoreElements() {
         return filter(alwaysFalse());
     }
 
@@ -4895,7 +4896,7 @@ public Observable ignoreElements() {
      * @see RxJava Wiki: isEmpty()
      * @see MSDN: Observable.Any
      */
-    public Observable isEmpty() {
+    public final Observable isEmpty() {
         return create(OperationAny.isEmpty(this));
     }
 
@@ -4923,7 +4924,7 @@ public Observable isEmpty() {
      * @see RxJava Wiki: join()
      * @see MSDN: Observable.Join
      */
-    public  Observable join(Observable right, Func1> leftDurationSelector,
+    public final  Observable join(Observable right, Func1> leftDurationSelector,
             Func1> rightDurationSelector,
             Func2 resultSelector) {
         return create(new OperationJoin(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
@@ -4941,7 +4942,7 @@ public  Observable join(Observable<
      * @see RxJava Wiki: last()
      * @see MSDN: Observable.lastAsync()
      */
-    public Observable last() {
+    public final Observable last() {
         return takeLast(1).single();
     }
 
@@ -4962,7 +4963,7 @@ public Observable last() {
      * @see RxJava Wiki: last()
      * @see MSDN: Observable.lastAsync()
      */
-    public Observable last(Func1 predicate) {
+    public final Observable last(Func1 predicate) {
         return filter(predicate).takeLast(1).single();
     }
 
@@ -4980,7 +4981,7 @@ public Observable last(Func1 predicate) {
      * @see RxJava Wiki: lastOrDefault()
      * @see MSDN: Observable.lastOrDefaultAsync()
      */
-    public Observable lastOrDefault(T defaultValue) {
+    public final Observable lastOrDefault(T defaultValue) {
         return takeLast(1).singleOrDefault(defaultValue);
     }
 
@@ -5001,7 +5002,7 @@ public Observable lastOrDefault(T defaultValue) {
      * @see RxJava Wiki: lastOrDefault()
      * @see MSDN: Observable.lastOrDefaultAsync()
      */
-    public Observable lastOrDefault(T defaultValue, Func1 predicate) {
+    public final Observable lastOrDefault(T defaultValue, Func1 predicate) {
         return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
     }
 
@@ -5017,10 +5018,10 @@ public Observable lastOrDefault(T defaultValue, Func1 pre
      * @see MSDN: Observable.LongCount
      * @see #count()
      */
-    public Observable longCount() {
+    public final Observable longCount() {
         return reduce(0L, new Func2() {
             @Override
-            public Long call(Long t1, T t2) {
+            public final Long call(Long t1, T t2) {
                 return t1 + 1;
             }
         });
@@ -5040,7 +5041,7 @@ public Long call(Long t1, T t2) {
      * @see RxJava Wiki: map()
      * @see MSDN: Observable.Select
      */
-    public  Observable map(Func1 func) {
+    public final  Observable map(Func1 func) {
         return create(OperationMap.map(this, func));
     }
 
@@ -5066,7 +5067,7 @@ public  Observable map(Func1 func) {
      * @deprecated
      */
     @Deprecated
-    public  Observable mapMany(Func1> func) {
+    public final  Observable mapMany(Func1> func) {
         return mergeMap(func);
     }
 
@@ -5088,7 +5089,7 @@ public  Observable mapMany(Func1 Observable mapWithIndex(Func2 func) {
+    public final  Observable mapWithIndex(Func2 func) {
         return create(OperationMap.mapWithIndex(this, func));
     }
 
@@ -5103,7 +5104,7 @@ public  Observable mapWithIndex(Func2 fun
      * @see RxJava Wiki: materialize()
      * @see MSDN: Observable.materialize
      */
-    public Observable> materialize() {
+    public final Observable> materialize() {
         return create(OperationMaterialize.materialize(this));
     }
 
@@ -5123,7 +5124,7 @@ public Observable> materialize() {
      * @see RxJava Wiki: max()
      * @see MSDN: Observable.Max
      */
-    public Observable max(Comparator comparator) {
+    public final Observable max(Comparator comparator) {
         return OperationMinMax.max(this, comparator);
     }
 
@@ -5141,7 +5142,7 @@ public Observable max(Comparator comparator) {
      * @see RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
-    public > Observable> maxBy(Func1 selector) {
+    public final > Observable> maxBy(Func1 selector) {
         return OperationMinMax.maxBy(this, selector);
     }
 
@@ -5163,7 +5164,7 @@ public > Observable> maxBy(Func1 s
      * @see RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
-    public  Observable> maxBy(Func1 selector, Comparator comparator) {
+    public final  Observable> maxBy(Func1 selector, Comparator comparator) {
         return OperationMinMax.maxBy(this, selector, comparator);
     }
 
@@ -5185,7 +5186,7 @@ public  Observable> maxBy(Func1 selector, Comparator
      * @see RxJava Wiki: flatMap()
      * @see #flatMap(Func1)
      */
-    public  Observable mergeMap(Func1> func) {
+    public final  Observable mergeMap(Func1> func) {
         return merge(map(func));
     }
 
@@ -5204,7 +5205,7 @@ public  Observable mergeMap(Func1 Observable mergeMap(
+    public final  Observable mergeMap(
             Func1> onNext,
             Func1> onError,
             Func0> onCompleted) {
@@ -5226,7 +5227,7 @@ public  Observable mergeMap(
      * @return an Observable that applies a function to the pair of values from the source
      *         Observable and the collection Observable.
      */
-    public  Observable mergeMap(Func1> collectionSelector,
+    public final  Observable mergeMap(Func1> collectionSelector,
             Func2 resultSelector) {
         return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
     }
@@ -5243,7 +5244,7 @@ public  Observable mergeMap(Func1 Observable mergeMapIterable(Func1> collectionSelector) {
+    public final  Observable mergeMapIterable(Func1> collectionSelector) {
         return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
     }
 
@@ -5263,7 +5264,7 @@ public  Observable mergeMapIterable(Func1 Observable mergeMapIterable(Func1> collectionSelector,
+    public final  Observable mergeMapIterable(Func1> collectionSelector,
             Func2 resultSelector) {
         return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
     }
@@ -5284,7 +5285,7 @@ public  Observable mergeMapIterable(Func1RxJava Wiki: min()
      * @see MSDN: Observable.Min
      */
-    public Observable min(Comparator comparator) {
+    public final Observable min(Comparator comparator) {
         return OperationMinMax.min(this, comparator);
     }
 
@@ -5302,7 +5303,7 @@ public Observable min(Comparator comparator) {
      * @see RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
-    public > Observable> minBy(Func1 selector) {
+    public final > Observable> minBy(Func1 selector) {
         return OperationMinMax.minBy(this, selector);
     }
 
@@ -5324,7 +5325,7 @@ public > Observable> minBy(Func1 s
      * @see RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
-    public  Observable> minBy(Func1 selector, Comparator comparator) {
+    public final  Observable> minBy(Func1 selector, Comparator comparator) {
         return OperationMinMax.minBy(this, selector, comparator);
     }
 
@@ -5344,7 +5345,7 @@ public  Observable> minBy(Func1 selector, Comparator
      * @see RxJava: Observable.publish() and Observable.multicast()
      * @see MSDN: Observable.Multicast
      */
-    public  Observable multicast(
+    public final  Observable multicast(
             final Func0> subjectFactory,
             final Func1, ? extends Observable> selector) {
         return OperationMulticast.multicast(this, subjectFactory, selector);
@@ -5362,7 +5363,7 @@ public  Observable multicast(
      *         source Observable to push results into the specified {@link Subject}
      * @see RxJava Wiki: Observable.publish() and Observable.multicast()
      */
-    public  ConnectableObservable multicast(Subject subject) {
+    public final  ConnectableObservable multicast(Subject subject) {
         return OperationMulticast.multicast(this, subject);
     }
 
@@ -5377,7 +5378,7 @@ public  ConnectableObservable multicast(Subject su
      *         notified on the specified {@link Scheduler}
      * @see RxJava Wiki: observeOn()
      */
-    public Observable observeOn(Scheduler scheduler) {
+    public final Observable observeOn(Scheduler scheduler) {
         return create(OperationObserveOn.observeOn(this, scheduler));
     }
 
@@ -5394,9 +5395,9 @@ public Observable observeOn(Scheduler scheduler) {
      * @see RxJava Wiki: ofType()
      * @see MSDN: Observable.OfType
      */
-    public  Observable ofType(final Class klass) {
+    public final  Observable ofType(final Class klass) {
         return filter(new Func1() {
-            public Boolean call(T t) {
+            public final Boolean call(T t) {
                 return klass.isInstance(t);
             }
         }).cast(klass);
@@ -5431,7 +5432,7 @@ public Boolean call(T t) {
      * @return the original Observable, with appropriately modified behavior
      * @see RxJava Wiki: onErrorResumeNext()
      */
-    public Observable onErrorResumeNext(final Func1> resumeFunction) {
+    public final Observable onErrorResumeNext(final Func1> resumeFunction) {
         return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
     }
 
@@ -5464,7 +5465,7 @@ public Observable onErrorResumeNext(final Func1RxJava Wiki: onErrorResumeNext()
      */
-    public Observable onErrorResumeNext(final Observable resumeSequence) {
+    public final Observable onErrorResumeNext(final Observable resumeSequence) {
         return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -5495,7 +5496,7 @@ public Observable onErrorResumeNext(final Observable resumeSeque
      * @return the original Observable with appropriately modified behavior
      * @see RxJava Wiki: onErrorReturn()
      */
-    public Observable onErrorReturn(Func1 resumeFunction) {
+    public final Observable onErrorReturn(Func1 resumeFunction) {
         return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
     }
 
@@ -5533,7 +5534,7 @@ public Observable onErrorReturn(Func1 resumeFunction)
      * @return the original Observable, with appropriately modified behavior
      * @see RxJava Wiki: onExceptionResumeNextViaObservable()
      */
-    public Observable onExceptionResumeNext(final Observable resumeSequence) {
+    public final Observable onExceptionResumeNext(final Observable resumeSequence) {
         return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -5548,7 +5549,7 @@ public Observable onExceptionResumeNext(final Observable resumeS
      * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
      * @see RxJava Wiki: parallel()
      */
-    public  Observable parallel(Func1, Observable> f) {
+    public final  Observable parallel(Func1, Observable> f) {
         return OperationParallel.parallel(this, f);
     }
 
@@ -5564,7 +5565,7 @@ public  Observable parallel(Func1, Observable> f) {
      * @return an Observable with the output of the {@link Func1} executed on a {@link Scheduler}
      * @see RxJava Wiki: parallel()
      */
-    public  Observable parallel(final Func1, Observable> f, final Scheduler s) {
+    public final  Observable parallel(final Func1, Observable> f, final Scheduler s) {
         return OperationParallel.parallel(this, f, s);
     }
 
@@ -5591,7 +5592,7 @@ private Subscription protectivelyWrapAndSubscribe(Observer o) {
      *         source Observable to emit items to its {@link Observer}s
      * @see RxJava Wiki: publish()
      */
-    public ConnectableObservable publish() {
+    public final ConnectableObservable publish() {
         return OperationMulticast.multicast(this, PublishSubject. create());
     }
 
@@ -5612,10 +5613,10 @@ public ConnectableObservable publish() {
      *         selector on a connectable observable sequence that shares a single
      *         subscription to the underlying sequence.
      */
-    public  Observable publish(Func1, ? extends Observable> selector) {
+    public final  Observable publish(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return PublishSubject.create();
             }
         }, selector);
@@ -5638,10 +5639,10 @@ public Subject call() {
      * @return an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with
      *         initialValue
      */
-    public  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
+    public final  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
         return multicast(new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return BehaviorSubject.create(initialValue);
             }
         }, selector);
@@ -5655,7 +5656,7 @@ public Subject call() {
      *            the initial value of the underlying BehaviorSubject
      * @return a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
      */
-    public ConnectableObservable publish(T initialValue) {
+    public final ConnectableObservable publish(T initialValue) {
         return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
     }
 
@@ -5668,7 +5669,7 @@ public ConnectableObservable publish(T initialValue) {
      * @return a {@link ConnectableObservable}
      * @see RxJava Wiki: publishLast()
      */
-    public ConnectableObservable publishLast() {
+    public final ConnectableObservable publishLast() {
         return OperationMulticast.multicast(this, AsyncSubject. create());
     }
 
@@ -5690,10 +5691,10 @@ public ConnectableObservable publishLast() {
      *         subscription to the underlying sequence containing only the last
      *         notification.
      */
-    public  Observable publishLast(Func1, ? extends Observable> selector) {
+    public final  Observable publishLast(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return AsyncSubject.create();
             }
         }, selector);
@@ -5726,7 +5727,7 @@ public Subject call() {
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
      */
-    public Observable reduce(Func2 accumulator) {
+    public final Observable reduce(Func2 accumulator) {
         /*
          * Discussion and confirmation of implementation at https://github.com/Netflix/RxJava/issues/423#issuecomment-27642532
          * 
@@ -5763,7 +5764,7 @@ public Observable reduce(Func2 accumulator) {
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
      */
-    public  Observable reduce(R initialValue, Func2 accumulator) {
+    public final  Observable reduce(R initialValue, Func2 accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
 
@@ -5777,7 +5778,7 @@ public  Observable reduce(R initialValue, Func2 accumulat
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
-    public Observable repeat() {
+    public final Observable repeat() {
         return this.repeat(Schedulers.currentThread());
     }
 
@@ -5793,7 +5794,7 @@ public Observable repeat() {
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
-    public Observable repeat(Scheduler scheduler) {
+    public final Observable repeat(Scheduler scheduler) {
         return create(OperationRepeat.repeat(this, scheduler));
     }
 
@@ -5808,7 +5809,7 @@ public Observable repeat(Scheduler scheduler) {
      *         source Observable to emit items to its {@link Observer}s
      * @see RxJava Wiki: replay()
      */
-    public ConnectableObservable replay() {
+    public final ConnectableObservable replay() {
         return OperationMulticast.multicast(this, ReplaySubject. create());
     }
 
@@ -5830,10 +5831,10 @@ public ConnectableObservable replay() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector) {
+    public final  Observable replay(Func1, ? extends Observable> selector) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return ReplaySubject.create();
             }
         }, selector);
@@ -5858,10 +5859,10 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize) {
+    public final  Observable replay(Func1, ? extends Observable> selector, final int bufferSize) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return OperationReplay.replayBuffered(bufferSize);
             }
         }, selector);
@@ -5890,7 +5891,7 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) {
+    public final  Observable replay(Func1, ? extends Observable> selector, int bufferSize, long time, TimeUnit unit) {
         return replay(selector, bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -5920,13 +5921,13 @@ public  Observable replay(Func1, ? extends Observabl
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
+    public final  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return OperationReplay.replayWindowed(time, unit, bufferSize, scheduler);
             }
         }, selector);
@@ -5953,10 +5954,10 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) {
+    public final  Observable replay(Func1, ? extends Observable> selector, final int bufferSize, final Scheduler scheduler) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return OperationReplay. createScheduledSubject(OperationReplay. replayBuffered(bufferSize), scheduler);
             }
         }, selector);
@@ -5985,7 +5986,7 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) {
+    public final  Observable replay(Func1, ? extends Observable> selector, long time, TimeUnit unit) {
         return replay(selector, time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -6015,10 +6016,10 @@ public  Observable replay(Func1, ? extends Observabl
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
+    public final  Observable replay(Func1, ? extends Observable> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return OperationReplay.replayWindowed(time, unit, -1, scheduler);
             }
         }, selector);
@@ -6044,10 +6045,10 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public  Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) {
+    public final  Observable replay(Func1, ? extends Observable> selector, final Scheduler scheduler) {
         return OperationMulticast.multicast(this, new Func0>() {
             @Override
-            public Subject call() {
+            public final Subject call() {
                 return OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler);
             }
         }, selector);
@@ -6066,7 +6067,7 @@ public Subject call() {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(int bufferSize) {
+    public final ConnectableObservable replay(int bufferSize) {
         return OperationMulticast.multicast(this, OperationReplay. replayBuffered(bufferSize));
     }
 
@@ -6087,7 +6088,7 @@ public ConnectableObservable replay(int bufferSize) {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) {
+    public final ConnectableObservable replay(int bufferSize, long time, TimeUnit unit) {
         return replay(bufferSize, time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -6112,7 +6113,7 @@ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit)
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
+    public final ConnectableObservable replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
@@ -6135,7 +6136,7 @@ public ConnectableObservable replay(int bufferSize, long time, TimeUnit unit,
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
+    public final ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
         return OperationMulticast.multicast(this,
                 OperationReplay.createScheduledSubject(
                         OperationReplay. replayBuffered(bufferSize), scheduler));
@@ -6158,7 +6159,7 @@ public ConnectableObservable replay(int bufferSize, Scheduler scheduler) {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(long time, TimeUnit unit) {
+    public final ConnectableObservable replay(long time, TimeUnit unit) {
         return replay(time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -6182,7 +6183,7 @@ public ConnectableObservable replay(long time, TimeUnit unit) {
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) {
+    public final ConnectableObservable replay(long time, TimeUnit unit, Scheduler scheduler) {
         return OperationMulticast.multicast(this, OperationReplay. replayWindowed(time, unit, -1, scheduler));
     }
 
@@ -6203,7 +6204,7 @@ public ConnectableObservable replay(long time, TimeUnit unit, Scheduler sched
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
-    public ConnectableObservable replay(Scheduler scheduler) {
+    public final ConnectableObservable replay(Scheduler scheduler) {
         return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject. create(), scheduler));
     }
 
@@ -6226,7 +6227,7 @@ public ConnectableObservable replay(Scheduler scheduler) {
      * @return the source Observable modified with retry logic
      * @see RxJava Wiki: retry()
      */
-    public Observable retry() {
+    public final Observable retry() {
         return create(OperationRetry.retry(this));
     }
 
@@ -6252,7 +6253,7 @@ public Observable retry() {
      * @return the source Observable modified with retry logic
      * @see RxJava Wiki: retry()
      */
-    public Observable retry(int retryCount) {
+    public final Observable retry(int retryCount) {
         return create(OperationRetry.retry(this, retryCount));
     }
 
@@ -6270,7 +6271,7 @@ public Observable retry(int retryCount) {
      *         emitted by the source Observable at the specified time interval
      * @see RxJava Wiki: sample()
      */
-    public Observable sample(long period, TimeUnit unit) {
+    public final Observable sample(long period, TimeUnit unit) {
         return create(OperationSample.sample(this, period, unit));
     }
 
@@ -6290,7 +6291,7 @@ public Observable sample(long period, TimeUnit unit) {
      *         emitted by the source Observable at the specified time interval
      * @see RxJava Wiki: sample()
      */
-    public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
+    public final Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
         return create(OperationSample.sample(this, period, unit, scheduler));
     }
 
@@ -6308,7 +6309,7 @@ public Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
      *         Observable emits an item or completes
      * @see RxJava Wiki: sample()
      */
-    public  Observable sample(Observable sampler) {
+    public final  Observable sample(Observable sampler) {
         return create(new OperationSample.SampleWithObservable(this, sampler));
     }
 
@@ -6333,7 +6334,7 @@ public  Observable sample(Observable sampler) {
      * @see RxJava Wiki: scan()
      * @see MSDN: Observable.Scan
      */
-    public Observable scan(Func2 accumulator) {
+    public final Observable scan(Func2 accumulator) {
         return create(OperationScan.scan(this, accumulator));
     }
 
@@ -6363,7 +6364,7 @@ public Observable scan(Func2 accumulator) {
      * @see RxJava Wiki: scan()
      * @see MSDN: Observable.Scan
      */
-    public  Observable scan(R initialValue, Func2 accumulator) {
+    public final  Observable scan(R initialValue, Func2 accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator));
     }
 
@@ -6382,7 +6383,7 @@ public  Observable scan(R initialValue, Func2 accumulator
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleAsync()
      */
-    public Observable single() {
+    public final Observable single() {
         return create(OperationSingle. single(this));
     }
 
@@ -6406,7 +6407,7 @@ public Observable single() {
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleAsync()
      */
-    public Observable single(Func1 predicate) {
+    public final Observable single(Func1 predicate) {
         return filter(predicate).single();
     }
 
@@ -6428,7 +6429,7 @@ public Observable single(Func1 predicate) {
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleOrDefaultAsync()
      */
-    public Observable singleOrDefault(T defaultValue) {
+    public final Observable singleOrDefault(T defaultValue) {
         return create(OperationSingle. singleOrDefault(this, defaultValue));
     }
 
@@ -6456,7 +6457,7 @@ public Observable singleOrDefault(T defaultValue) {
      * @see RxJava Wiki: single()
      * @see MSDN: Observable.singleOrDefaultAsync()
      */
-    public Observable singleOrDefault(T defaultValue, Func1 predicate) {
+    public final Observable singleOrDefault(T defaultValue, Func1 predicate) {
         return filter(predicate).singleOrDefault(defaultValue);
     }
 
@@ -6473,7 +6474,7 @@ public Observable singleOrDefault(T defaultValue, Func1 p
      *         source Observable emits
      * @see RxJava Wiki: skip()
      */
-    public Observable skip(int num) {
+    public final Observable skip(int num) {
         return create(OperationSkip.skip(this, num));
     }
 
@@ -6489,7 +6490,7 @@ public Observable skip(int num) {
      * @return an Observable that skips values before the given time ellapses
      * @see RxJava Wiki: skip()
      */
-    public Observable skip(long time, TimeUnit unit) {
+    public final Observable skip(long time, TimeUnit unit) {
         return skip(time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -6509,7 +6510,7 @@ public Observable skip(long time, TimeUnit unit) {
      *         while waiting on the given scheduler
      * @see RxJava Wiki: skip()
      */
-    public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkip.SkipTimed(this, time, unit, scheduler));
     }
 
@@ -6533,7 +6534,7 @@ public Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
-    public Observable skipLast(int count) {
+    public final Observable skipLast(int count) {
         return create(OperationSkipLast.skipLast(this, count));
     }
 
@@ -6552,7 +6553,7 @@ public Observable skipLast(int count) {
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
-    public Observable skipLast(long time, TimeUnit unit) {
+    public final Observable skipLast(long time, TimeUnit unit) {
         return skipLast(time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -6573,7 +6574,7 @@ public Observable skipLast(long time, TimeUnit unit) {
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
-    public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationSkipLast.SkipLastTimed(this, time, unit, scheduler));
     }
 
@@ -6591,7 +6592,7 @@ public Observable skipLast(long time, TimeUnit unit, Scheduler scheduler) {
      * @see RxJava Wiki: skipUntil()
      * @see MSDN: Observable.SkipUntil
      */
-    public  Observable skipUntil(Observable other) {
+    public final  Observable skipUntil(Observable other) {
         return create(new OperationSkipUntil(this, other));
     }
 
@@ -6610,7 +6611,7 @@ public  Observable skipUntil(Observable other) {
      * @see RxJava Wiki: skipWhile()
      * @see MSDN: Observable.SkipWhile
      */
-    public Observable skipWhile(Func1 predicate) {
+    public final Observable skipWhile(Func1 predicate) {
         return create(OperationSkipWhile.skipWhile(this, predicate));
     }
 
@@ -6631,7 +6632,7 @@ public Observable skipWhile(Func1 predicate) {
      * @see RxJava Wiki: skipWhileWithIndex()
      * @see MSDN: Observable.SkipWhile
      */
-    public Observable skipWhileWithIndex(Func2 predicate) {
+    public final Observable skipWhileWithIndex(Func2 predicate) {
         return create(OperationSkipWhile.skipWhileWithIndex(this, predicate));
     }
 
@@ -6647,7 +6648,7 @@ public Observable skipWhileWithIndex(Func2 predi
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(Iterable values) {
+    public final Observable startWith(Iterable values) {
         return concat(Observable. from(values), this);
     }
 
@@ -6666,7 +6667,7 @@ public Observable startWith(Iterable values) {
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
      */
-    public Observable startWith(Iterable values, Scheduler scheduler) {
+    public final Observable startWith(Iterable values, Scheduler scheduler) {
         return concat(from(values, scheduler), this);
     }
 
@@ -6681,7 +6682,7 @@ public Observable startWith(Iterable values, Scheduler scheduler) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1) {
+    public final Observable startWith(T t1) {
         return concat(Observable. from(t1), this);
     }
 
@@ -6698,7 +6699,7 @@ public Observable startWith(T t1) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2) {
+    public final Observable startWith(T t1, T t2) {
         return concat(Observable. from(t1, t2), this);
     }
 
@@ -6717,7 +6718,7 @@ public Observable startWith(T t1, T t2) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3) {
+    public final Observable startWith(T t1, T t2, T t3) {
         return concat(Observable. from(t1, t2, t3), this);
     }
 
@@ -6738,7 +6739,7 @@ public Observable startWith(T t1, T t2, T t3) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4) {
+    public final Observable startWith(T t1, T t2, T t3, T t4) {
         return concat(Observable. from(t1, t2, t3, t4), this);
     }
 
@@ -6761,7 +6762,7 @@ public Observable startWith(T t1, T t2, T t3, T t4) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5) {
+    public final Observable startWith(T t1, T t2, T t3, T t4, T t5) {
         return concat(Observable. from(t1, t2, t3, t4, t5), this);
     }
 
@@ -6786,7 +6787,7 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
+    public final 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);
     }
 
@@ -6813,7 +6814,7 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
+    public final 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);
     }
 
@@ -6842,7 +6843,7 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
+    public final 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);
     }
 
@@ -6873,7 +6874,7 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
      * @return an Observable that exhibits the modified behavior
      * @see RxJava Wiki: startWith()
      */
-    public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) {
+    public final 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);
     }
 
@@ -6891,7 +6892,7 @@ public Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
      */
-    public Observable startWith(T[] values, Scheduler scheduler) {
+    public final Observable startWith(T[] values, Scheduler scheduler) {
         return startWith(Arrays.asList(values), scheduler);
     }
 
@@ -6900,21 +6901,21 @@ public Observable startWith(T[] values, Scheduler scheduler) {
      * 
      * @return
      */
-    public Subscription subscribe() {
+    public final Subscription subscribe() {
         return protectivelyWrapAndSubscribe(new Observer() {
 
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 // do nothing
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 throw new OnErrorNotImplementedException(e);
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
                 // do nothing
             }
 
@@ -6929,7 +6930,7 @@ public void onNext(T args) {
      * @return
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext) {
+    public final Subscription subscribe(final Action1 onNext) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -6942,17 +6943,17 @@ public Subscription subscribe(final Action1 onNext) {
         return protectivelyWrapAndSubscribe(new Observer() {
 
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 // do nothing
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 throw new OnErrorNotImplementedException(e);
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
                 onNext.call(args);
             }
 
@@ -6968,7 +6969,7 @@ public void onNext(T args) {
      * @return
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError) {
+    public final Subscription subscribe(final Action1 onNext, final Action1 onError) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -6985,17 +6986,17 @@ public Subscription subscribe(final Action1 onNext, final Action1() {
 
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 // do nothing
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 onError.call(e);
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
                 onNext.call(args);
             }
 
@@ -7012,7 +7013,7 @@ public void onNext(T args) {
      * @return
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) {
+    public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -7031,17 +7032,17 @@ public Subscription subscribe(final Action1 onNext, final Action1() {
 
             @Override
-            public void onCompleted() {
+            public final void onCompleted() {
                 onComplete.call();
             }
 
             @Override
-            public void onError(Throwable e) {
+            public final void onError(Throwable e) {
                 onError.call(e);
             }
 
             @Override
-            public void onNext(T args) {
+            public final void onNext(T args) {
                 onNext.call(args);
             }
 
@@ -7059,7 +7060,7 @@ public void onNext(T args) {
      * @return
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
+    public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
     }
 
@@ -7073,7 +7074,7 @@ public Subscription subscribe(final Action1 onNext, final Action1RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
+    public final Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError);
     }
 
@@ -7086,7 +7087,7 @@ public Subscription subscribe(final Action1 onNext, final Action1RxJava Wiki: onNext, onCompleted, and onError
      */
-    public Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
+    public final Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext);
     }
 
@@ -7120,7 +7121,7 @@ public Subscription subscribe(final Action1 onNext, Scheduler schedul
      *             if the {@link Observer} provided as the
      *             argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer observer) {
+    public final Subscription subscribe(Observer observer) {
         // allow the hook to intercept and/or decorate
         OnSubscribeFunc onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
         // validate and proceed
@@ -7203,7 +7204,7 @@ public Subscription subscribe(Observer observer) {
      * @throws IllegalArgumentException
      *             if an argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer observer, Scheduler scheduler) {
+    public final Subscription subscribe(Observer observer, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(observer);
     }
 
@@ -7219,7 +7220,7 @@ public Subscription subscribe(Observer observer, Scheduler scheduler)
      *         unsubscriptions happen on the specified {@link Scheduler}
      * @see RxJava Wiki: subscribeOn()
      */
-    public Observable subscribeOn(Scheduler scheduler) {
+    public final Observable subscribeOn(Scheduler scheduler) {
         return create(OperationSubscribeOn.subscribeOn(this, scheduler));
     }
 
@@ -7239,7 +7240,7 @@ public Observable subscribeOn(Scheduler scheduler) {
      * @see RxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
-    public Observable sumDouble(Func1 valueExtractor) {
+    public final Observable sumDouble(Func1 valueExtractor) {
         return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
     }
 
@@ -7259,7 +7260,7 @@ public Observable sumDouble(Func1 valueExtractor) {
      * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
-    public Observable sumFloat(Func1 valueExtractor) {
+    public final Observable sumFloat(Func1 valueExtractor) {
         return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
     }
 
@@ -7279,7 +7280,7 @@ public Observable sumFloat(Func1 valueExtractor) {
      * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
-    public Observable sumInteger(Func1 valueExtractor) {
+    public final Observable sumInteger(Func1 valueExtractor) {
         return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
     }
 
@@ -7299,7 +7300,7 @@ public Observable sumInteger(Func1 valueExtractor)
      * @see RxJava Wiki: sumLong()
      * @see MSDN: Observable.Sum
      */
-    public Observable sumLong(Func1 valueExtractor) {
+    public final Observable sumLong(Func1 valueExtractor) {
         return create(new OperationSum.SumLongExtractor(this, valueExtractor));
     }
 
@@ -7317,7 +7318,7 @@ public Observable sumLong(Func1 valueExtractor) {
      *         transformation function to each item emitted by the source
      *         Observable and then switch
      */
-    public  Observable switchMap(Func1> func) {
+    public final  Observable switchMap(Func1> func) {
         return switchOnNext(map(func));
     }
 
@@ -7337,7 +7338,7 @@ public  Observable switchMap(Func1RxJava Wiki: synchronize()
      */
-    public Observable synchronize() {
+    public final Observable synchronize() {
         return create(OperationSynchronize.synchronize(this));
     }
 
@@ -7361,7 +7362,7 @@ public Observable synchronize() {
      *         the source Observable, and that synchronously notifies its {@link Observer}s
      * @see RxJava Wiki: synchronize()
      */
-    public Observable synchronize(Object lock) {
+    public final Observable synchronize(Object lock) {
         return create(OperationSynchronize.synchronize(this, lock));
     }
 
@@ -7382,7 +7383,7 @@ public Observable synchronize(Object lock) {
      *         num items
      * @see RxJava Wiki: take()
      */
-    public Observable take(final int num) {
+    public final Observable take(final int num) {
         return create(OperationTake.take(this, num));
     }
 
@@ -7400,7 +7401,7 @@ public Observable take(final int num) {
      *         Observable before the time runs out
      * @see RxJava Wiki: take()
      */
-    public Observable take(long time, TimeUnit unit) {
+    public final Observable take(long time, TimeUnit unit) {
         return take(time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -7421,7 +7422,7 @@ public Observable take(long time, TimeUnit unit) {
      *         scheduler
      * @see RxJava Wiki: take()
      */
-    public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable take(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTake.TakeTimed(this, time, unit, scheduler));
     }
 
@@ -7439,7 +7440,7 @@ public Observable take(long time, TimeUnit unit, Scheduler scheduler) {
      * @see MSDN: Observable.firstAsync()
      */
     @Deprecated
-    public Observable takeFirst() {
+    public final Observable takeFirst() {
         return take(1);
     }
 
@@ -7458,7 +7459,7 @@ public Observable takeFirst() {
      * @see RxJava Wiki: first()
      * @see MSDN: Observable.firstAsync()
      */
-    public Observable takeFirst(Func1 predicate) {
+    public final Observable takeFirst(Func1 predicate) {
         return filter(predicate).take(1);
     }
 
@@ -7475,7 +7476,7 @@ public Observable takeFirst(Func1 predicate) {
      *         emitted by the source Observable
      * @see RxJava Wiki: takeLast()
      */
-    public Observable takeLast(final int count) {
+    public final Observable takeLast(final int count) {
         return create(OperationTakeLast.takeLast(this, count));
     }
 
@@ -7497,7 +7498,7 @@ public Observable takeLast(final int count) {
      *         source Observable which were emitted not before it completed
      *         minus a time window
      */
-    public Observable takeLast(int count, long time, TimeUnit unit) {
+    public final Observable takeLast(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -7524,7 +7525,7 @@ public Observable takeLast(int count, long time, TimeUnit unit) {
      *         minus a time window, where the timing information is provided by
      *         the given {@code scheduler}
      */
-    public Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
         if (count < 0) {
             throw new IllegalArgumentException("count >= 0 required");
         }
@@ -7545,7 +7546,7 @@ public Observable takeLast(int count, long time, TimeUnit unit, Scheduler sch
      * @return an Observable that emits the items from the source Observable
      *         that were emitted not before it completed minus a time window
      */
-    public Observable takeLast(long time, TimeUnit unit) {
+    public final Observable takeLast(long time, TimeUnit unit) {
         return takeLast(time, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -7568,7 +7569,7 @@ public Observable takeLast(long time, TimeUnit unit) {
      *         that were emitted not before it completed minus a time window,
      *         where the timing information is provided by the given Scheduler
      */
-    public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
     }
 
@@ -7581,7 +7582,7 @@ public Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
      *            the number of items to take last
      * @return an Observable that emits a single list containing the last {@code count} elements emitted by the source Observable
      */
-    public Observable> takeLastBuffer(int count) {
+    public final Observable> takeLastBuffer(int count) {
         return takeLast(count).toList();
     }
 
@@ -7601,7 +7602,7 @@ public Observable> takeLastBuffer(int count) {
      * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
      *         it completed minus a time window
      */
-    public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
+    public final Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit).toList();
     }
 
@@ -7624,7 +7625,7 @@ public Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
      * @return an Observable that emits a single List containing at most {@code count} items emitted by the source Observable not before
      *         it completed minus a time window
      */
-    public Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(count, time, unit, scheduler).toList();
     }
 
@@ -7644,7 +7645,7 @@ public Observable> takeLastBuffer(int count, long time, TimeUnit unit, S
      *         were emitted by the source Observable not before it completed
      *         minus a time window
      */
-    public Observable> takeLastBuffer(long time, TimeUnit unit) {
+    public final Observable> takeLastBuffer(long time, TimeUnit unit) {
         return takeLast(time, unit).toList();
     }
 
@@ -7668,7 +7669,7 @@ public Observable> takeLastBuffer(long time, TimeUnit unit) {
      *         minus a time window, where the timing information is provided by
      *         the given scheduler
      */
-    public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(time, unit, scheduler).toList();
     }
 
@@ -7688,7 +7689,7 @@ public Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler sc
      *         such time as other emits its first item
      * @see RxJava Wiki: takeUntil()
      */
-    public  Observable takeUntil(Observable other) {
+    public final  Observable takeUntil(Observable other) {
         return OperationTakeUntil.takeUntil(this, other);
     }
 
@@ -7706,7 +7707,7 @@ public  Observable takeUntil(Observable other) {
      *         predicate
      * @see RxJava Wiki: takeWhile()
      */
-    public Observable takeWhile(final Func1 predicate) {
+    public final Observable takeWhile(final Func1 predicate) {
         return create(OperationTakeWhile.takeWhile(this, predicate));
     }
 
@@ -7727,7 +7728,7 @@ public Observable takeWhile(final Func1 predicate) {
      *         item, then completes
      * @see RxJava Wiki: takeWhileWithIndex()
      */
-    public Observable takeWhileWithIndex(final Func2 predicate) {
+    public final Observable takeWhileWithIndex(final Func2 predicate) {
         return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
     }
 
@@ -7747,7 +7748,7 @@ public Observable takeWhileWithIndex(final Func2RxJava Wiki: then()
      * @see MSDN: Observable.Then
      */
-    public  Plan0 then(Func1 selector) {
+    public final  Plan0 then(Func1 selector) {
         return OperationJoinPatterns.then(this, selector);
     }
 
@@ -7769,7 +7770,7 @@ public  Plan0 then(Func1 selector) {
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleFirst()
      */
-    public Observable throttleFirst(long windowDuration, TimeUnit unit) {
+    public final Observable throttleFirst(long windowDuration, TimeUnit unit) {
         return create(OperationThrottleFirst.throttleFirst(this, windowDuration, unit));
     }
 
@@ -7794,7 +7795,7 @@ public Observable throttleFirst(long windowDuration, TimeUnit unit) {
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleFirst()
      */
-    public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
+    public final Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
         return create(OperationThrottleFirst.throttleFirst(this, skipDuration, unit, scheduler));
     }
 
@@ -7817,7 +7818,7 @@ public Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler s
      * @see RxJava Wiki: throttleLast()
      * @see #sample(long, TimeUnit)
      */
-    public Observable throttleLast(long intervalDuration, TimeUnit unit) {
+    public final Observable throttleLast(long intervalDuration, TimeUnit unit) {
         return sample(intervalDuration, unit);
     }
 
@@ -7843,7 +7844,7 @@ public Observable throttleLast(long intervalDuration, TimeUnit unit) {
      * @see RxJava Wiki: throttleLast()
      * @see #sample(long, TimeUnit, Scheduler)
      */
-    public Observable throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
+    public final Observable throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
         return sample(intervalDuration, unit, scheduler);
     }
 
@@ -7875,7 +7876,7 @@ public Observable throttleLast(long intervalDuration, TimeUnit unit, Schedule
      * @see RxJava Wiki: throttleWithTimeout()
      * @see #debounce(long, TimeUnit)
      */
-    public Observable throttleWithTimeout(long timeout, TimeUnit unit) {
+    public final Observable throttleWithTimeout(long timeout, TimeUnit unit) {
         return create(OperationDebounce.debounce(this, timeout, unit));
     }
 
@@ -7909,7 +7910,7 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit) {
      * @see RxJava Wiki: throttleWithTimeout()
      * @see #debounce(long, TimeUnit, Scheduler)
      */
-    public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
+    public final Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
         return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
     }
 
@@ -7923,7 +7924,7 @@ public Observable throttleWithTimeout(long timeout, TimeUnit unit, Scheduler
      * @see RxJava Wiki: timeInterval()
      * @see MSDN: Observable.TimeInterval
      */
-    public Observable> timeInterval() {
+    public final Observable> timeInterval() {
         return create(OperationTimeInterval.timeInterval(this));
     }
 
@@ -7939,7 +7940,7 @@ public Observable> timeInterval() {
      * @see RxJava Wiki: timeInterval()
      * @see MSDN: Observable.TimeInterval
      */
-    public Observable> timeInterval(Scheduler scheduler) {
+    public final Observable> timeInterval(Scheduler scheduler) {
         return create(OperationTimeInterval.timeInterval(this, scheduler));
     }
 
@@ -7960,7 +7961,7 @@ public Observable> timeInterval(Scheduler scheduler) {
      * @return an Observable which completes if either the first item or any subsequent item
      *         doesn't arrive within the time window specified by the timeout selectors' Observable.
      */
-    public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
+    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
         if (firstTimeoutSelector == null) {
             throw new NullPointerException("firstTimeoutSelector");
         }
@@ -7988,7 +7989,7 @@ public  Observable timeout(Func0> firstTimeoutS
      *         if either the first item or any subsequent item
      *         doesn't arrive within the time window specified by the timeout selectors' Observable
      */
-    public  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
+    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
         if (firstTimeoutSelector == null) {
             throw new NullPointerException("firstTimeoutSelector");
         }
@@ -8012,7 +8013,7 @@ public  Observable timeout(Func0> firstTimeoutS
      * @return an observable which completes if a source item doesn't arrive after the
      *         previous one in the time window specified by the per-item observable.
      */
-    public  Observable timeout(Func1> timeoutSelector) {
+    public final  Observable timeout(Func1> timeoutSelector) {
         return timeout(timeoutSelector, Observable. empty());
     }
 
@@ -8034,7 +8035,7 @@ public  Observable timeout(Func1> timeo
      *         item doesn't arrive after the
      *         previous one in the time window specified by the per-item observable
      */
-    public  Observable timeout(Func1> timeoutSelector, Observable other) {
+    public final  Observable timeout(Func1> timeoutSelector, Observable other) {
         if (other == null) {
             throw new NullPointerException("other");
         }
@@ -8059,7 +8060,7 @@ public  Observable timeout(Func1> timeo
      * @see RxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit) {
+    public final Observable timeout(long timeout, TimeUnit timeUnit) {
         return create(OperationTimeout.timeout(this, timeout, timeUnit));
     }
 
@@ -8084,7 +8085,7 @@ public Observable timeout(long timeout, TimeUnit timeUnit) {
      * @see RxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other) {
+    public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other) {
         return create(OperationTimeout.timeout(this, timeout, timeUnit, other));
     }
 
@@ -8111,7 +8112,7 @@ public Observable timeout(long timeout, TimeUnit timeUnit, ObservableRxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
+    public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
         return create(OperationTimeout.timeout(this, timeout, timeUnit, other, scheduler));
     }
 
@@ -8135,7 +8136,7 @@ public Observable timeout(long timeout, TimeUnit timeUnit, ObservableRxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
-    public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
+    public final Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
         return create(OperationTimeout.timeout(this, timeout, timeUnit, scheduler));
     }
 
@@ -8149,7 +8150,7 @@ public Observable timeout(long timeout, TimeUnit timeUnit, Scheduler schedule
      * @see RxJava Wiki: timestamp()
      * @see MSDN: Observable.Timestamp
      */
-    public Observable> timestamp() {
+    public final Observable> timestamp() {
         return create(OperationTimestamp.timestamp(this));
     }
 
@@ -8165,7 +8166,7 @@ public Observable> timestamp() {
      * @see RxJava Wiki: timestamp()
      * @see MSDN: Observable.Timestamp
      */
-    public Observable> timestamp(Scheduler scheduler) {
+    public final Observable> timestamp(Scheduler scheduler) {
         return create(OperationTimestamp.timestamp(this, scheduler));
     }
 
@@ -8176,7 +8177,7 @@ public Observable> timestamp(Scheduler scheduler) {
      * @return a BlockingObservable version of this Observable
      * @see RxJava Wiki: Blocking Observable Operators
      */
-    public BlockingObservable toBlockingObservable() {
+    public final BlockingObservable toBlockingObservable() {
         return BlockingObservable.from(this);
     }
 
@@ -8201,7 +8202,7 @@ public BlockingObservable toBlockingObservable() {
      *         the items emitted by the source Observable.
      * @see RxJava Wiki: toList()
      */
-    public Observable> toList() {
+    public final Observable> toList() {
         return create(OperationToObservableList.toObservableList(this));
     }
 
@@ -8222,7 +8223,7 @@ public Observable> toList() {
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
-    public  Observable> toMap(Func1 keySelector) {
+    public final  Observable> toMap(Func1 keySelector) {
         return create(OperationToMap.toMap(this, keySelector));
     }
 
@@ -8246,7 +8247,7 @@ public  Observable> toMap(Func1 keySelector
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
-    public  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
+    public final  Observable> toMap(Func1 keySelector, Func1 valueSelector) {
         return create(OperationToMap.toMap(this, keySelector, valueSelector));
     }
 
@@ -8269,7 +8270,7 @@ public  Observable> toMap(Func1 keySelec
      *         items emitted by the source Observable
      * @see RxJava Wiki: toMap()
      */
-    public  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
+    public final  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
         return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
     }
 
@@ -8288,7 +8289,7 @@ public  Observable> toMap(Func1 keySelec
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
-    public  Observable>> toMultimap(Func1 keySelector) {
+    public final  Observable>> toMultimap(Func1 keySelector) {
         return create(OperationToMultimap.toMultimap(this, keySelector));
     }
 
@@ -8311,7 +8312,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
+    public final  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector));
     }
 
@@ -8335,7 +8336,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMap()
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
+    public final  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory));
     }
 
@@ -8362,7 +8363,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toMap()
      */
-    public  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
+    public final  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
         return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));
     }
 
@@ -8382,7 +8383,7 @@ public  Observable>> toMultimap(Func1RxJava Wiki: toSortedList()
      */
-    public Observable> toSortedList() {
+    public final Observable> toSortedList() {
         return create(OperationToObservableSortedList.toSortedList(this));
     }
 
@@ -8400,7 +8401,7 @@ public Observable> toSortedList() {
      *         sorted order
      * @see RxJava Wiki: toSortedList()
      */
-    public Observable> toSortedList(Func2 sortFunction) {
+    public final Observable> toSortedList(Func2 sortFunction) {
         return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
     }
 
@@ -8419,7 +8420,7 @@ public Observable> toSortedList(Func2 sor
      * @see #filter(Func1)
      */
     @Deprecated
-    public Observable where(Func1 predicate) {
+    public final Observable where(Func1 predicate) {
         return filter(predicate);
     }
 
@@ -8442,7 +8443,7 @@ public Observable where(Func1 predicate) {
      *         closingSelector argument emits an item
      * @see RxJava Wiki: window()
      */
-    public  Observable> window(Func0> closingSelector) {
+    public final  Observable> window(Func0> closingSelector) {
         return create(OperationWindow.window(this, closingSelector));
     }
 
@@ -8462,7 +8463,7 @@ public  Observable> window(Func0count items
      * @see RxJava Wiki: window()
      */
-    public Observable> window(int count) {
+    public final Observable> window(int count) {
         return create(OperationWindow.window(this, count));
     }
 
@@ -8486,7 +8487,7 @@ public Observable> window(int count) {
      *         items containing at most count items
      * @see RxJava Wiki: window()
      */
-    public Observable> window(int count, int skip) {
+    public final Observable> window(int count, int skip) {
         return create(OperationWindow.window(this, count, skip));
     }
 
@@ -8515,7 +8516,7 @@ public Observable> window(int count, int skip) {
      *         fixed timespan has elapsed
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, long timeshift, TimeUnit unit) {
+    public final Observable> window(long timespan, long timeshift, TimeUnit unit) {
         return create(OperationWindow.window(this, timespan, timeshift, unit));
     }
 
@@ -8547,7 +8548,7 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      *         fixed timespan has elapsed
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
     }
 
@@ -8571,7 +8572,7 @@ public Observable> window(long timespan, long timeshift, TimeUnit
      *         windows with a fixed duration
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, TimeUnit unit) {
+    public final Observable> window(long timespan, TimeUnit unit) {
         return create(OperationWindow.window(this, timespan, unit));
     }
 
@@ -8600,7 +8601,7 @@ public Observable> window(long timespan, TimeUnit unit) {
      *         maximum capacity (whichever occurs first)
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, TimeUnit unit, int count) {
+    public final Observable> window(long timespan, TimeUnit unit, int count) {
         return create(OperationWindow.window(this, timespan, unit, count));
     }
 
@@ -8632,7 +8633,7 @@ public Observable> window(long timespan, TimeUnit unit, int count)
      *         maximum capacity (whichever occurs first).
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+    public final Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
         return create(OperationWindow.window(this, timespan, unit, count, scheduler));
     }
 
@@ -8659,7 +8660,7 @@ public Observable> window(long timespan, TimeUnit unit, int count,
      *         windows with a fixed duration
      * @see RxJava Wiki: window()
      */
-    public Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) {
+    public final Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(this, timespan, unit, scheduler));
     }
 
@@ -8683,7 +8684,7 @@ public Observable> window(long timespan, TimeUnit unit, Scheduler
      *         source Observable that are governed by the specified {@link Observable}s emitting items
      * @see RxJava Wiki: window()
      */
-    public  Observable> window(Observable windowOpenings, Func1> closingSelector) {
+    public final  Observable> window(Observable windowOpenings, Func1> closingSelector) {
         return create(OperationWindow.window(this, windowOpenings, closingSelector));
     }
 
@@ -8701,7 +8702,7 @@ public  Observable> window(Observable Observable> window(Observable boundary) {
+    public final  Observable> window(Observable boundary) {
         return create(OperationWindow.window(this, boundary));
     }
 
@@ -8725,7 +8726,7 @@ public  Observable> window(Observable boundary) {
      * @return an Observable that pairs up values from this Observable and an
      *         Iterable sequence and applies a function.
      */
-    public  Observable zip(Iterable other, Func2 zipFunction) {
+    public final  Observable zip(Iterable other, Func2 zipFunction) {
         return create(OperationZip.zipIterable(this, other, zipFunction));
     }
 
@@ -8745,7 +8746,7 @@ public  Observable zip(Iterable other, Func2 Observable zip(Observable other, Func2 zipFunction) {
+    public final  Observable zip(Observable other, Func2 zipFunction) {
         return zip(this, other, zipFunction);
     }
 
@@ -8762,7 +8763,7 @@ public NeverObservable() {
             super(new OnSubscribeFunc() {
 
                 @Override
-                public Subscription onSubscribe(Observer t1) {
+                public final Subscription onSubscribe(Observer t1) {
                     return Subscriptions.empty();
                 }
 
@@ -8789,7 +8790,7 @@ public ThrowObservable(final Throwable exception) {
                  * @return a reference to the subscription
                  */
                 @Override
-                public Subscription onSubscribe(Observer observer) {
+                public final Subscription onSubscribe(Observer observer) {
                     observer.onError(exception);
                     return Subscriptions.empty();
                 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index d18d742b23..b6f4ee748d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -207,29 +207,20 @@ public void onCompleted() {
         }
     }
 
-    protected static  OnSubscribeFunc neverSubscribe() {
-        return new OnSubscribeFunc() {
-            @Override
-            public Subscription onSubscribe(Observer t1) {
-                return Subscriptions.empty();
-            }
-        };
-    }
-
     /** A grouped observable with subject-like behavior. */
     public static class GroupSubject extends GroupedObservable implements Observer {
         protected final Subject publish;
 
-        public GroupSubject(K key, Subject publish) {
-            super(key, OperationGroupByUntil. neverSubscribe());
+        public GroupSubject(K key, final Subject publish) {
+            super(key, new OnSubscribeFunc() {
+                @Override
+                public Subscription onSubscribe(Observer o) {
+                    return publish.subscribe(o);
+                }
+            });
             this.publish = publish;
         }
 
-        @Override
-        public Subscription subscribe(Observer observer) {
-            return publish.subscribe(observer);
-        }
-
         @Override
         public void onNext(V args) {
             publish.onNext(args);

From 6ee4364f002f6089e9efeeae0b1a4628eb60ad7b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 14 Jan 2014 23:41:27 -0800
Subject: [PATCH 219/441] Updating License Headers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- since I’m touching all files for the other commits I’ll update the copyright headers as well
---
 .../main/scala/rx/lang/scala/Subscription.scala | 15 +++++++++++++++
 .../async/operators/OperationStartFuture.java   | 15 +++++++++++++++
 .../operators/OperationForEachFutureTest.java   | 15 +++++++++++++++
 .../src/main/java/rx/Statement.java             | 15 +++++++++++++++
 rxjava-core/src/main/java/rx/Notification.java  |  2 +-
 rxjava-core/src/main/java/rx/Observable.java    |  2 +-
 rxjava-core/src/main/java/rx/Observer.java      |  2 +-
 rxjava-core/src/main/java/rx/Scheduler.java     |  2 +-
 rxjava-core/src/main/java/rx/Subscription.java  |  2 +-
 .../rx/concurrency/CurrentThreadScheduler.java  |  2 +-
 .../java/rx/concurrency/ExecutorScheduler.java  |  2 +-
 .../java/rx/concurrency/ImmediateScheduler.java |  2 +-
 .../java/rx/concurrency/NewThreadScheduler.java |  2 +-
 .../src/main/java/rx/concurrency/README.txt     | 16 ++++++++++++++++
 .../main/java/rx/concurrency/Schedulers.java    |  2 +-
 .../main/java/rx/concurrency/TestScheduler.java |  2 +-
 .../src/main/java/rx/joins/ActivePlan0.java     |  2 +-
 .../src/main/java/rx/joins/ActivePlan1.java     |  2 +-
 .../src/main/java/rx/joins/ActivePlan2.java     |  2 +-
 .../src/main/java/rx/joins/ActivePlan3.java     |  2 +-
 .../src/main/java/rx/joins/JoinObserver.java    |  2 +-
 .../src/main/java/rx/joins/JoinObserver1.java   |  2 +-
 rxjava-core/src/main/java/rx/joins/Pattern.java |  2 +-
 .../src/main/java/rx/joins/Pattern1.java        |  2 +-
 .../src/main/java/rx/joins/Pattern2.java        |  2 +-
 .../src/main/java/rx/joins/Pattern3.java        |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan0.java   |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan1.java   |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan2.java   |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan3.java   |  2 +-
 .../java/rx/observables/BlockingObservable.java |  2 +-
 .../rx/observables/ConnectableObservable.java   |  2 +-
 .../java/rx/observables/GroupedObservable.java  |  2 +-
 .../java/rx/operators/ChunkedOperation.java     |  2 +-
 .../main/java/rx/operators/OperationAll.java    |  2 +-
 .../main/java/rx/operators/OperationAmb.java    |  2 +-
 .../main/java/rx/operators/OperationAny.java    |  2 +-
 .../rx/operators/OperationAsObservable.java     |  2 +-
 .../java/rx/operators/OperationAverage.java     |  2 +-
 .../main/java/rx/operators/OperationBuffer.java |  2 +-
 .../main/java/rx/operators/OperationCache.java  |  2 +-
 .../main/java/rx/operators/OperationCast.java   |  2 +-
 .../rx/operators/OperationCombineLatest.java    |  2 +-
 .../main/java/rx/operators/OperationConcat.java |  2 +-
 .../java/rx/operators/OperationDebounce.java    |  2 +-
 .../rx/operators/OperationDefaultIfEmpty.java   |  2 +-
 .../main/java/rx/operators/OperationDefer.java  |  2 +-
 .../main/java/rx/operators/OperationDelay.java  |  2 +-
 .../rx/operators/OperationDematerialize.java    |  2 +-
 .../java/rx/operators/OperationDistinct.java    |  2 +-
 .../OperationDistinctUntilChanged.java          |  2 +-
 .../java/rx/operators/OperationDoOnEach.java    |  2 +-
 .../java/rx/operators/OperationElementAt.java   |  2 +-
 .../main/java/rx/operators/OperationFilter.java |  2 +-
 .../java/rx/operators/OperationFinally.java     |  2 +-
 .../java/rx/operators/OperationFlatMap.java     |  2 +-
 .../java/rx/operators/OperationGroupBy.java     |  2 +-
 .../rx/operators/OperationGroupByUntil.java     |  2 +-
 .../java/rx/operators/OperationGroupJoin.java   |  2 +-
 .../java/rx/operators/OperationInterval.java    |  2 +-
 .../main/java/rx/operators/OperationJoin.java   |  2 +-
 .../rx/operators/OperationJoinPatterns.java     |  2 +-
 .../main/java/rx/operators/OperationLatest.java |  2 +-
 .../main/java/rx/operators/OperationMap.java    |  2 +-
 .../java/rx/operators/OperationMaterialize.java |  2 +-
 .../main/java/rx/operators/OperationMerge.java  |  2 +-
 .../rx/operators/OperationMergeDelayError.java  |  2 +-
 .../main/java/rx/operators/OperationMinMax.java |  2 +-
 .../java/rx/operators/OperationMostRecent.java  |  2 +-
 .../java/rx/operators/OperationMulticast.java   |  2 +-
 .../main/java/rx/operators/OperationNext.java   |  2 +-
 .../java/rx/operators/OperationObserveOn.java   |  2 +-
 .../OperationOnErrorResumeNextViaFunction.java  |  2 +-
 ...OperationOnErrorResumeNextViaObservable.java |  2 +-
 .../rx/operators/OperationOnErrorReturn.java    |  2 +-
 ...ationOnExceptionResumeNextViaObservable.java |  2 +-
 .../java/rx/operators/OperationParallel.java    |  2 +-
 .../rx/operators/OperationParallelMerge.java    |  2 +-
 .../java/rx/operators/OperationRefCount.java    |  2 +-
 .../main/java/rx/operators/OperationRepeat.java |  2 +-
 .../main/java/rx/operators/OperationReplay.java |  2 +-
 .../main/java/rx/operators/OperationRetry.java  | 17 ++++++++++++++++-
 .../main/java/rx/operators/OperationSample.java |  2 +-
 .../main/java/rx/operators/OperationScan.java   |  2 +-
 .../rx/operators/OperationSequenceEqual.java    |  2 +-
 .../main/java/rx/operators/OperationSingle.java |  2 +-
 .../main/java/rx/operators/OperationSkip.java   |  2 +-
 .../java/rx/operators/OperationSkipLast.java    |  2 +-
 .../java/rx/operators/OperationSkipUntil.java   |  2 +-
 .../java/rx/operators/OperationSkipWhile.java   |  2 +-
 .../java/rx/operators/OperationSubscribeOn.java |  2 +-
 .../main/java/rx/operators/OperationSum.java    |  2 +-
 .../main/java/rx/operators/OperationSwitch.java |  2 +-
 .../java/rx/operators/OperationSynchronize.java |  2 +-
 .../main/java/rx/operators/OperationTake.java   |  2 +-
 .../java/rx/operators/OperationTakeLast.java    |  2 +-
 .../java/rx/operators/OperationTakeUntil.java   |  2 +-
 .../java/rx/operators/OperationTakeWhile.java   |  2 +-
 .../rx/operators/OperationThrottleFirst.java    |  2 +-
 .../rx/operators/OperationTimeInterval.java     |  2 +-
 .../java/rx/operators/OperationTimeout.java     |  2 +-
 .../main/java/rx/operators/OperationTimer.java  |  2 +-
 .../java/rx/operators/OperationTimestamp.java   |  2 +-
 .../java/rx/operators/OperationToFuture.java    |  2 +-
 .../java/rx/operators/OperationToIterator.java  |  2 +-
 .../main/java/rx/operators/OperationToMap.java  |  2 +-
 .../java/rx/operators/OperationToMultimap.java  |  2 +-
 .../operators/OperationToObservableFuture.java  |  2 +-
 .../OperationToObservableIterable.java          |  2 +-
 .../rx/operators/OperationToObservableList.java |  2 +-
 .../OperationToObservableSortedList.java        |  2 +-
 .../main/java/rx/operators/OperationUsing.java  |  2 +-
 .../main/java/rx/operators/OperationWindow.java |  2 +-
 .../main/java/rx/operators/OperationZip.java    |  2 +-
 .../src/main/java/rx/operators/README.txt       |  2 +-
 .../operators/SafeObservableSubscription.java   |  2 +-
 .../main/java/rx/operators/SafeObserver.java    |  2 +-
 .../java/rx/operators/SynchronizedObserver.java |  2 +-
 .../src/main/java/rx/operators/package.html     |  2 +-
 rxjava-core/src/main/java/rx/package-info.java  |  2 +-
 .../java/rx/plugins/RxJavaErrorHandler.java     |  2 +-
 .../rx/plugins/RxJavaErrorHandlerDefault.java   |  2 +-
 .../plugins/RxJavaObservableExecutionHook.java  |  2 +-
 .../RxJavaObservableExecutionHookDefault.java   |  2 +-
 .../src/main/java/rx/plugins/RxJavaPlugins.java |  2 +-
 .../rx/schedulers/CurrentThreadScheduler.java   |  2 +-
 .../java/rx/schedulers/DiscardableAction.java   |  2 +-
 .../java/rx/schedulers/ExecutorScheduler.java   |  2 +-
 .../GenericScheduledExecutorService.java        |  2 +-
 .../java/rx/schedulers/ImmediateScheduler.java  |  2 +-
 .../java/rx/schedulers/NewThreadScheduler.java  |  2 +-
 .../src/main/java/rx/schedulers/Schedulers.java |  2 +-
 .../main/java/rx/schedulers/SleepingAction.java |  2 +-
 .../main/java/rx/schedulers/TestScheduler.java  |  2 +-
 .../main/java/rx/schedulers/package-info.java   |  2 +-
 .../src/main/java/rx/subjects/AsyncSubject.java |  2 +-
 .../main/java/rx/subjects/BehaviorSubject.java  |  2 +-
 .../main/java/rx/subjects/PublishSubject.java   |  2 +-
 .../main/java/rx/subjects/ReplaySubject.java    |  2 +-
 .../src/main/java/rx/subjects/Subject.java      |  2 +-
 .../rx/subjects/SubjectSubscriptionManager.java |  2 +-
 .../rx/subscriptions/BooleanSubscription.java   |  2 +-
 .../rx/subscriptions/CompositeSubscription.java |  2 +-
 .../MultipleAssignmentSubscription.java         |  2 +-
 .../rx/subscriptions/RefCountSubscription.java  |  2 +-
 .../rx/subscriptions/SerialSubscription.java    |  2 +-
 .../java/rx/subscriptions/Subscriptions.java    |  2 +-
 .../main/java/rx/util/CompositeException.java   |  2 +-
 .../src/main/java/rx/util/Exceptions.java       |  2 +-
 .../rx/util/OnErrorNotImplementedException.java |  2 +-
 rxjava-core/src/main/java/rx/util/Range.java    |  2 +-
 .../src/main/java/rx/util/TimeInterval.java     |  2 +-
 .../src/main/java/rx/util/Timestamped.java      |  2 +-
 .../src/main/java/rx/util/functions/Action.java |  2 +-
 .../main/java/rx/util/functions/Action0.java    |  2 +-
 .../main/java/rx/util/functions/Action1.java    |  2 +-
 .../main/java/rx/util/functions/Action2.java    |  2 +-
 .../main/java/rx/util/functions/Action3.java    |  2 +-
 .../main/java/rx/util/functions/Action4.java    |  2 +-
 .../main/java/rx/util/functions/Action5.java    |  2 +-
 .../main/java/rx/util/functions/Action6.java    |  2 +-
 .../main/java/rx/util/functions/Action7.java    |  2 +-
 .../main/java/rx/util/functions/Action8.java    |  2 +-
 .../main/java/rx/util/functions/Action9.java    |  2 +-
 .../main/java/rx/util/functions/ActionN.java    |  2 +-
 .../main/java/rx/util/functions/Actions.java    |  2 +-
 .../src/main/java/rx/util/functions/Func0.java  |  2 +-
 .../src/main/java/rx/util/functions/Func1.java  |  2 +-
 .../src/main/java/rx/util/functions/Func2.java  |  2 +-
 .../src/main/java/rx/util/functions/Func3.java  |  2 +-
 .../src/main/java/rx/util/functions/Func4.java  |  2 +-
 .../src/main/java/rx/util/functions/Func5.java  |  2 +-
 .../src/main/java/rx/util/functions/Func6.java  |  2 +-
 .../src/main/java/rx/util/functions/Func7.java  |  2 +-
 .../src/main/java/rx/util/functions/Func8.java  |  2 +-
 .../src/main/java/rx/util/functions/Func9.java  |  2 +-
 .../src/main/java/rx/util/functions/FuncN.java  |  2 +-
 .../main/java/rx/util/functions/Function.java   |  2 +-
 .../main/java/rx/util/functions/Functions.java  |  2 +-
 .../src/main/java/rx/util/functions/Not.java    |  2 +-
 .../src/test/java/rx/CombineLatestTests.java    |  2 +-
 rxjava-core/src/test/java/rx/ConcatTests.java   |  2 +-
 .../src/test/java/rx/CovarianceTest.java        |  2 +-
 .../src/test/java/rx/ErrorHandlingTests.java    |  2 +-
 rxjava-core/src/test/java/rx/EventStream.java   |  2 +-
 rxjava-core/src/test/java/rx/GroupByTests.java  |  2 +-
 rxjava-core/src/test/java/rx/IntervalDemo.java  |  2 +-
 rxjava-core/src/test/java/rx/MergeTests.java    |  2 +-
 .../src/test/java/rx/ObservableDoOnTest.java    |  2 +-
 .../src/test/java/rx/ObservableTests.java       |  2 +-
 .../src/test/java/rx/ObservableWindowTests.java |  2 +-
 rxjava-core/src/test/java/rx/ReduceTests.java   |  2 +-
 rxjava-core/src/test/java/rx/RefCountTests.java |  2 +-
 rxjava-core/src/test/java/rx/ScanTests.java     |  2 +-
 .../src/test/java/rx/StartWithTests.java        |  2 +-
 .../src/test/java/rx/ThrottleFirstTests.java    |  2 +-
 .../src/test/java/rx/ThrottleLastTests.java     |  2 +-
 .../test/java/rx/ThrottleWithTimeoutTests.java  |  2 +-
 rxjava-core/src/test/java/rx/TimeoutTests.java  |  2 +-
 rxjava-core/src/test/java/rx/ZipTests.java      |  2 +-
 .../rx/observables/BlockingObservableTest.java  |  2 +-
 .../java/rx/operators/OperationAllTest.java     |  2 +-
 .../java/rx/operators/OperationAmbTest.java     |  2 +-
 .../java/rx/operators/OperationAnyTest.java     |  2 +-
 .../java/rx/operators/OperationAverageTest.java |  2 +-
 .../java/rx/operators/OperationBufferTest.java  |  2 +-
 .../java/rx/operators/OperationCacheTest.java   |  2 +-
 .../java/rx/operators/OperationCastTest.java    |  2 +-
 .../operators/OperationCombineLatestTest.java   |  2 +-
 .../java/rx/operators/OperationConcatTest.java  |  2 +-
 .../rx/operators/OperationDebounceTest.java     |  2 +-
 .../operators/OperationDefaultIfEmptyTest.java  |  2 +-
 .../java/rx/operators/OperationDeferTest.java   |  2 +-
 .../java/rx/operators/OperationDelayTest.java   |  2 +-
 .../operators/OperationDematerializeTest.java   |  2 +-
 .../rx/operators/OperationDistinctTest.java     |  2 +-
 .../OperationDistinctUntilChangedTest.java      |  2 +-
 .../rx/operators/OperationDoOnEachTest.java     |  2 +-
 .../rx/operators/OperationElementAtTest.java    |  2 +-
 .../java/rx/operators/OperationFilterTest.java  |  2 +-
 .../java/rx/operators/OperationFinallyTest.java |  2 +-
 .../operators/OperationFirstOrDefaultTest.java  |  2 +-
 .../java/rx/operators/OperationFlatMapTest.java |  2 +-
 .../java/rx/operators/OperationGroupByTest.java |  2 +-
 .../rx/operators/OperationGroupByUntilTest.java |  2 +-
 .../rx/operators/OperationGroupJoinTest.java    |  2 +-
 .../rx/operators/OperationIntervalTest.java     |  2 +-
 .../java/rx/operators/OperationJoinTest.java    |  2 +-
 .../java/rx/operators/OperationJoinsTest.java   |  2 +-
 .../java/rx/operators/OperationLastTest.java    |  2 +-
 .../java/rx/operators/OperationLatestTest.java  |  2 +-
 .../java/rx/operators/OperationMapTest.java     |  2 +-
 .../rx/operators/OperationMaterializeTest.java  |  2 +-
 .../operators/OperationMergeDelayErrorTest.java |  2 +-
 .../java/rx/operators/OperationMergeTest.java   |  2 +-
 .../java/rx/operators/OperationMinMaxTest.java  |  2 +-
 .../rx/operators/OperationMostRecentTest.java   |  2 +-
 .../rx/operators/OperationMulticastTest.java    |  2 +-
 .../java/rx/operators/OperationNextTest.java    |  2 +-
 .../rx/operators/OperationObserveOnTest.java    |  2 +-
 ...erationOnErrorResumeNextViaFunctionTest.java |  2 +-
 ...ationOnErrorResumeNextViaObservableTest.java |  2 +-
 .../operators/OperationOnErrorReturnTest.java   |  2 +-
 ...nOnExceptionResumeNextViaObservableTest.java |  2 +-
 .../operators/OperationParallelMergeTest.java   |  2 +-
 .../rx/operators/OperationParallelTest.java     |  2 +-
 .../java/rx/operators/OperationReduceTest.java  |  2 +-
 .../java/rx/operators/OperationRepeatTest.java  |  2 +-
 .../java/rx/operators/OperationReplayTest.java  |  2 +-
 .../java/rx/operators/OperationRetryTest.java   |  2 +-
 .../java/rx/operators/OperationSampleTest.java  |  2 +-
 .../java/rx/operators/OperationScanTest.java    |  2 +-
 .../operators/OperationSequenceEqualTests.java  |  2 +-
 .../java/rx/operators/OperationSingleTest.java  |  2 +-
 .../rx/operators/OperationSkipLastTest.java     |  2 +-
 .../java/rx/operators/OperationSkipTest.java    |  2 +-
 .../rx/operators/OperationSkipUntilTest.java    |  2 +-
 .../rx/operators/OperationSkipWhileTest.java    |  2 +-
 .../rx/operators/OperationSubscribeOnTest.java  |  2 +-
 .../java/rx/operators/OperationSumTest.java     |  2 +-
 .../java/rx/operators/OperationSwitchTest.java  |  2 +-
 .../rx/operators/OperationSynchronizeTest.java  |  2 +-
 .../rx/operators/OperationTakeLastTest.java     |  2 +-
 .../java/rx/operators/OperationTakeTest.java    |  2 +-
 .../rx/operators/OperationTakeUntilTest.java    |  2 +-
 .../rx/operators/OperationTakeWhileTest.java    |  2 +-
 .../operators/OperationThrottleFirstTest.java   |  2 +-
 .../rx/operators/OperationTimeIntervalTest.java |  2 +-
 .../java/rx/operators/OperationTimeoutTest.java |  2 +-
 .../java/rx/operators/OperationTimerTest.java   |  2 +-
 .../rx/operators/OperationTimestampTest.java    |  2 +-
 .../rx/operators/OperationToFutureTest.java     |  2 +-
 .../rx/operators/OperationToIteratorTest.java   |  2 +-
 .../java/rx/operators/OperationToMapTest.java   |  2 +-
 .../rx/operators/OperationToMultimapTest.java   |  2 +-
 .../OperationToObservableFutureTest.java        |  2 +-
 .../OperationToObservableIterableTest.java      |  2 +-
 .../OperationToObservableListTest.java          |  2 +-
 .../OperationToObservableSortedListTest.java    |  2 +-
 .../java/rx/operators/OperationUsingTest.java   |  2 +-
 .../java/rx/operators/OperationWindowTest.java  |  2 +-
 .../java/rx/operators/OperationZipTest.java     |  2 +-
 .../operators/OperationZipTestCompletion.java   |  2 +-
 .../java/rx/operators/OperatorTesterTest.java   |  2 +-
 .../SafeObservableSubscriptionTest.java         |  2 +-
 .../java/rx/operators/SafeObserverTest.java     |  2 +-
 .../rx/operators/SynchronizedObserverTest.java  |  2 +-
 .../test/java/rx/operators/TakeWhileTest.java   |  2 +-
 .../rx/operators/TimeIntervalObserverTest.java  |  2 +-
 .../java/rx/performance/PerformanceTest.java    |  2 +-
 .../rx/performance/TestChainPerformance.java    |  2 +-
 .../test/java/rx/plugins/RxJavaPluginsTest.java |  2 +-
 .../AbstractSchedulerConcurrencyTests.java      |  2 +-
 .../rx/schedulers/AbstractSchedulerTests.java   |  2 +-
 .../schedulers/CurrentThreadSchedulerTest.java  |  2 +-
 .../rx/schedulers/ExecutorSchedulerTests.java   |  2 +-
 .../rx/schedulers/ImmediateSchedulerTest.java   |  2 +-
 .../rx/schedulers/NewThreadSchedulerTest.java   |  2 +-
 .../schedulers/SchedulerPerformanceTests.java   |  2 +-
 .../rx/schedulers/TestRecursionMemoryUsage.java |  2 +-
 .../java/rx/schedulers/TestSchedulerTest.java   |  2 +-
 .../test/java/rx/subjects/AsyncSubjectTest.java |  2 +-
 .../java/rx/subjects/BehaviorSubjectTest.java   |  2 +-
 .../java/rx/subjects/PublishSubjectTest.java    |  2 +-
 .../subjects/ReplaySubjectConcurrencyTest.java  |  2 +-
 .../java/rx/subjects/ReplaySubjectTest.java     |  2 +-
 .../rx/subjects/SubjectPerformanceTests.java    |  2 +-
 .../CompositeSubscriptionTest.java              |  2 +-
 .../MultipleAssignmentSubscriptionTest.java     |  2 +-
 .../subscriptions/RefCountSubscriptionTest.java |  2 +-
 .../subscriptions/SerialSubscriptionTests.java  |  2 +-
 .../rx/subscriptions/SubscriptionsTest.java     |  2 +-
 .../src/test/java/rx/test/OperatorTester.java   |  2 +-
 .../src/test/java/rx/util/AssertObservable.java |  2 +-
 .../test/java/rx/util/AssertObservableTest.java |  2 +-
 .../src/test/java/rx/util/RangeTest.java        |  2 +-
 316 files changed, 402 insertions(+), 311 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala
index a5703c682e..69ab35c1cd 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscription.scala
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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.
+ */
 
 /**
  * Copyright 2013 Netflix, Inc.
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
index 992023e7f5..b84badd815 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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.
+ */
  /**
   * Copyright 2013 Netflix, Inc.
   *
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
index e5915050ee..e7784262c3 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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.
+ */
  /**
   * Copyright 2013 Netflix, Inc.
   *
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
index 7ed5201327..d58c047b6d 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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 java.util.Map;
diff --git a/rxjava-core/src/main/java/rx/Notification.java b/rxjava-core/src/main/java/rx/Notification.java
index 996e217d50..48524d5c6c 100644
--- a/rxjava-core/src/main/java/rx/Notification.java
+++ b/rxjava-core/src/main/java/rx/Notification.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 1a47c0da69..ca763bc469 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/Observer.java b/rxjava-core/src/main/java/rx/Observer.java
index 3d35066ba4..8ff0a99230 100644
--- a/rxjava-core/src/main/java/rx/Observer.java
+++ b/rxjava-core/src/main/java/rx/Observer.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index a4cc789cd4..19059d1f75 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/Subscription.java b/rxjava-core/src/main/java/rx/Subscription.java
index ceb8510f00..0248fd603f 100644
--- a/rxjava-core/src/main/java/rx/Subscription.java
+++ b/rxjava-core/src/main/java/rx/Subscription.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
index cf87221af0..b5e5fd1d14 100644
--- a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
index c68d5e7ae8..4f43643451 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
index 1e1ba108d6..b37a7db13e 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
index 67d93b2553..39ce1be3ae 100644
--- a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/README.txt b/rxjava-core/src/main/java/rx/concurrency/README.txt
index d9048bbbc9..41ed405b26 100644
--- a/rxjava-core/src/main/java/rx/concurrency/README.txt
+++ b/rxjava-core/src/main/java/rx/concurrency/README.txt
@@ -1,3 +1,19 @@
+====
+    Copyright 2014 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.
+====
+
 This package is deprecated and will be removed prior to a 1.0 release.
 
 Use rx.schedulers.* instead of rx.concurrency.*
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
index f64ebd7d26..0147aa5b36 100644
--- a/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/concurrency/Schedulers.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
index 0a40fe7eef..696975d753 100644
--- a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan0.java b/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
index d70b0859bf..aaaf75c447 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan0.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
index 1d192a308b..1c59c5a4bd 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
index c580fd4f76..2dfc7f252e 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
index 3930137ac7..a905aeca6a 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver.java b/rxjava-core/src/main/java/rx/joins/JoinObserver.java
index 68fc3c612e..80fe6d9aa0 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index 5b5a67eea3..24695cdce2 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern.java b/rxjava-core/src/main/java/rx/joins/Pattern.java
index d7ec2d07d0..a1d9f58a10 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern1.java b/rxjava-core/src/main/java/rx/joins/Pattern1.java
index d9f707a951..32f73cad15 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern1.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern1.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern2.java b/rxjava-core/src/main/java/rx/joins/Pattern2.java
index 13c5c6a758..579717aa15 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern2.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern2.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern3.java b/rxjava-core/src/main/java/rx/joins/Pattern3.java
index 614748cf2e..d15a3cf48a 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern3.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern3.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/Plan0.java b/rxjava-core/src/main/java/rx/joins/Plan0.java
index 6017c0646e..30a7b79197 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan0.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan0.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan1.java b/rxjava-core/src/main/java/rx/joins/Plan1.java
index 1487a805fb..6502ca0bed 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan1.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan1.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan2.java b/rxjava-core/src/main/java/rx/joins/Plan2.java
index a30f341b27..59a69952fe 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan2.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan2.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/joins/Plan3.java b/rxjava-core/src/main/java/rx/joins/Plan3.java
index 7b14ddbc9a..8d84ea4ad1 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan3.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan3.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 262f5f4b80..f80a1df4a4 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
index 1826905eaf..ec117da2ba 100644
--- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
index f40e8c40af..a43a02c010 100644
--- a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 19523ee473..6fa8879777 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
index f3e0f0ebcd..2a68c0bd71 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAll.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAmb.java b/rxjava-core/src/main/java/rx/operators/OperationAmb.java
index 639de2fa85..16a6c307dd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAmb.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAny.java b/rxjava-core/src/main/java/rx/operators/OperationAny.java
index a06058bece..cb650a2bee 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAny.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAny.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
index 0594c684c9..b266345984 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
index 09ce63ecff..01a7ad0765 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index 811676bd71..b0946f0351 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCache.java b/rxjava-core/src/main/java/rx/operators/OperationCache.java
index 71c681a179..eb10bc9ab6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCache.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCache.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCast.java b/rxjava-core/src/main/java/rx/operators/OperationCast.java
index 7b1a21cbda..6e5a9831e4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCast.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
index 272ac6af7f..9e05b1c7c4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
index ed99ea2b2b..1d12200ba8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 3201eaaf97..a5ebd33127 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
index 3bd2a316b9..924a508500 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefer.java b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
index 0d326b364e..387db931a4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 7df55048fe..5bd391758e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
index 8e958cbc14..9bfd901f7e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
index d2db484254..9fc8f94ffe 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
index eb1d6ed083..b78da98f96 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
index 7bdf886976..f3f63e41ff 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDoOnEach.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationElementAt.java b/rxjava-core/src/main/java/rx/operators/OperationElementAt.java
index 3001043c80..729258e734 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationElementAt.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationElementAt.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFilter.java b/rxjava-core/src/main/java/rx/operators/OperationFilter.java
index 560600dc9c..ada9aa9a29 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFilter.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFinally.java b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
index f8237cbb20..0d0667f1f8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFinally.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
index c94025dcaf..8e9c6202b4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
index a30b97523f..ebe2392bf8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index b6f4ee748d..5fcca3da4f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
index 68d60f3a35..8ec39d7d67 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index e6711bfb9e..1d3bd15715 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index 8c20a6e0d0..057aefc45b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
index 2855318554..21c02fb90e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 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
diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
index a24d0f55a3..6cc213c37d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMap.java b/rxjava-core/src/main/java/rx/operators/OperationMap.java
index 5233d9a798..e224c40eeb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMap.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
index f1998ffe64..66356e1db0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMerge.java b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
index 8080ef0aab..3a69d64981 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index 704ea181f1..959675c298 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
index eff93eeaa5..1a4d4d757b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
index a68d113706..7af2f3fb1a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
index 5fe35d3e65..bbffa40ac5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java
index 001dea1c18..45d1fff72b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
index e3c3dfa3b2..b024a44de9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
index 0122a8c5e1..5e4f8480ff 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
index 6c14d3618a..1f4ac3d24c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
index d5d6a9fbc7..fc4a672195 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
index 864ba0730e..1b079624f9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallel.java b/rxjava-core/src/main/java/rx/operators/OperationParallel.java
index 4db3b8e6b6..4cc2f1679b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationParallel.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
index 86aa31c609..5ea77a50c4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
index d19b700afd..2c1d07ec8b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java
index 8bdff97776..ade09aecce 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
index 2e1394a74e..e8574c98da 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRetry.java b/rxjava-core/src/main/java/rx/operators/OperationRetry.java
index 450dfe3ebb..3e55077849 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRetry.java
@@ -1,7 +1,22 @@
+/**
+ * Copyright 2014 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;
 
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
index f2badbe6f7..57ceb97d22 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationScan.java b/rxjava-core/src/main/java/rx/operators/OperationScan.java
index a5eedfee46..3c58e053c5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationScan.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
index 16300b664e..d11bcc08e4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSingle.java b/rxjava-core/src/main/java/rx/operators/OperationSingle.java
index 2269cd8b44..871d565092 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSingle.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSingle.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 96dc644ae2..706ae08c80 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index 85d7bbfa70..c20da050a1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
index 4486d4df08..4f6cd185e7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java b/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
index 6bc747e9bf..54476adb69 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
index fe7aa00216..c46d98b20f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
index b05d3d605c..4a12335e42 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSum.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 94d80b3436..c6fc01d5af 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
index 5ba8c0a98e..3e7af78552 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTake.java b/rxjava-core/src/main/java/rx/operators/OperationTake.java
index 9096e6a906..2d11d06761 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTake.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index e11910fa68..b4e64cf2ec 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
index 4f344d72a1..b9ecc2c742 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
index 479badf6a6..219295d626 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
index 8f5568d1b5..6b009e1e27 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
index fe45b0c72d..b2c67b4851 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
index 408cd73df7..cf838a6061 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 6b7cdbe25c..f5e5197a1a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
index a56e82c0bd..9cd086841a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
index d4433da9d6..005cd3a1e4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
index 038c0ba38c..318728c438 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
index 770d4d68a3..e15c180aec 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
index 98d469b65f..a04c3545cb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
index 875a0dc0d8..5d25bcb593 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
index 77d93e3851..1ae63c6143 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
index f29582537e..550343587e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
index cfc7ba35fa..aaa42bf7b3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationUsing.java b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
index dd2a588c2b..6476c03745 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationUsing.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index 0f99b8e66e..eae1f059ef 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationZip.java b/rxjava-core/src/main/java/rx/operators/OperationZip.java
index bb6bec6d4a..06a2f111e2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationZip.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/README.txt b/rxjava-core/src/main/java/rx/operators/README.txt
index 1be4baa962..a3a2a3e394 100644
--- a/rxjava-core/src/main/java/rx/operators/README.txt
+++ b/rxjava-core/src/main/java/rx/operators/README.txt
@@ -1,5 +1,5 @@
 ====
-    Copyright 2013 Netflix, Inc.
+    Copyright 2014 Netflix, Inc.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java b/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
index ef33ebd3d3..98c3b35408 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 965bc68963..fc8d868531 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
index 2daef3e280..494489d186 100644
--- a/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Netflix, Inc.
+ * Copyright 2014 Netflix, Inc.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/rxjava-core/src/main/java/rx/operators/package.html b/rxjava-core/src/main/java/rx/operators/package.html
index 80ba7542bf..657138e453 100644
--- a/rxjava-core/src/main/java/rx/operators/package.html
+++ b/rxjava-core/src/main/java/rx/operators/package.html
@@ -1,6 +1,6 @@
  subscribe to infinite sequence");
+                        System.out.println("Starting thread: " + Thread.currentThread());
+                        int i = 1;
+                        while (!o.isUnsubscribed()) {
+                            o.onNext(i++);
+                            Thread.yield();
+                        }
+                        o.onCompleted();
+                        latch.countDown();
+                        System.out.println("Ending thread: " + Thread.currentThread());
+                    }
+                });
+                t.start();
+
+            }
+
+        });
+    }
 }

From 9b3fca18c1ff2720b6ea7dfe841fccf11613623c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 4 Feb 2014 16:25:02 -0800
Subject: [PATCH 302/441] Subscribers for common factory methods

Similar to Observers.
---
 rxjava-core/src/main/java/rx/Subscriber.java  |  21 ---
 .../main/java/rx/observers/Subscribers.java   | 151 ++++++++++++++++++
 .../java/rx/observers/TestSubscriber.java     |   2 +-
 3 files changed, 152 insertions(+), 22 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/observers/Subscribers.java

diff --git a/rxjava-core/src/main/java/rx/Subscriber.java b/rxjava-core/src/main/java/rx/Subscriber.java
index cfce1c60c5..3ad986813c 100644
--- a/rxjava-core/src/main/java/rx/Subscriber.java
+++ b/rxjava-core/src/main/java/rx/Subscriber.java
@@ -47,27 +47,6 @@ protected Subscriber(Subscriber op) {
         this(op.cs);
     }
 
-    public static  Subscriber from(final Observer o) {
-        return new Subscriber() {
-
-            @Override
-            public void onCompleted() {
-                o.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                o.onError(e);
-            }
-
-            @Override
-            public void onNext(T t) {
-                o.onNext(t);
-            }
-
-        };
-    }
-
     /**
      * Used to register an unsubscribe callback.
      */
diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
new file mode 100644
index 0000000000..4cf5e48d14
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.java
@@ -0,0 +1,151 @@
+package rx.observers;
+
+import rx.Observer;
+import rx.Subscriber;
+import rx.util.OnErrorNotImplementedException;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+public class Subscribers {
+
+    public static  Subscriber from(final Observer o) {
+        return new Subscriber() {
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                o.onNext(t);
+            }
+
+        };
+    }
+
+    /**
+     * Create an empty Subscriber that ignores all events.
+     */
+    public static final  Subscriber create() {
+        return new Subscriber() {
+
+            @Override
+            public final void onCompleted() {
+                // do nothing
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                throw new OnErrorNotImplementedException(e);
+            }
+
+            @Override
+            public final void onNext(T args) {
+                // do nothing
+            }
+
+        };
+    }
+
+    /**
+     * Create an Subscriber that receives `onNext` and ignores `onError` and `onCompleted`.
+     */
+    public static final  Subscriber create(final Action1 onNext) {
+        if (onNext == null) {
+            throw new IllegalArgumentException("onNext can not be null");
+        }
+
+        return new Subscriber() {
+
+            @Override
+            public final void onCompleted() {
+                // do nothing
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                throw new OnErrorNotImplementedException(e);
+            }
+
+            @Override
+            public final void onNext(T args) {
+                onNext.call(args);
+            }
+
+        };
+    }
+
+    /**
+     * Create an Subscriber that receives `onNext` and `onError` and ignores `onCompleted`.
+     * 
+     */
+    public static final  Subscriber create(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");
+        }
+
+        return new Subscriber() {
+
+            @Override
+            public final void onCompleted() {
+                // do nothing
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onError.call(e);
+            }
+
+            @Override
+            public final void onNext(T args) {
+                onNext.call(args);
+            }
+
+        };
+    }
+
+    /**
+     * Create an Subscriber that receives `onNext`, `onError` and `onCompleted`.
+     * 
+     */
+    public static final  Subscriber create(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");
+        }
+
+        return new Subscriber() {
+
+            @Override
+            public final void onCompleted() {
+                onComplete.call();
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onError.call(e);
+            }
+
+            @Override
+            public final void onNext(T args) {
+                onNext.call(args);
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index 677c9dcb94..097c6e8e24 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -26,7 +26,7 @@
  */
 public class TestSubscriber extends Subscriber {
 
-    private final Subscriber EMPTY = Subscriber.from(new EmptyObserver());
+    private final Subscriber EMPTY = Subscribers.create();
 
     private final TestObserver testObserver;
 

From cf28bce52ea15dba3e6be587ba5b4d43b1029ea9 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 4 Feb 2014 16:25:55 -0800
Subject: [PATCH 303/441] OperatorZipIterable

---
 rxjava-core/src/main/java/rx/Observable.java  |   5 +-
 .../rx/operators/OperatorZipIterable.java     |  72 ++++
 .../rx/operators/OperatorZipIterableTest.java | 339 ++++++++++++++++++
 .../java/rx/operators/OperatorZipTest.java    | 259 -------------
 4 files changed, 413 insertions(+), 262 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 101c412340..5337bf3123 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -108,6 +108,7 @@
 import rx.operators.OperatorTimestamp;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
+import rx.operators.OperatorZipIterable;
 import rx.plugins.RxJavaObservableExecutionHook;
 import rx.plugins.RxJavaPlugins;
 import rx.schedulers.Schedulers;
@@ -8407,9 +8408,7 @@ public final  Observable> window(Observable boundary) {
      * @return an Observable that pairs up values from the source Observable and the {@code other} Iterable sequence and emits the results of {@code zipFunction} applied to these pairs
      */
     public final  Observable zip(Iterable other, Func2 zipFunction) {
-//        return create(OperatorZip.zipIterable(this, other, zipFunction));
-        // TODO fix this
-        return null;
+        return lift(new OperatorZipIterable(other, zipFunction));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
new file mode 100644
index 0000000000..eac5f80809
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
@@ -0,0 +1,72 @@
+/**
+ * Copyright 2014 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 java.util.Iterator;
+
+import rx.Subscriber;
+import rx.observers.Subscribers;
+import rx.util.functions.Func2;
+
+public final class OperatorZipIterable implements Operator {
+
+    final Iterable iterable;
+    final Func2 zipFunction;
+
+    public OperatorZipIterable(Iterable iterable, Func2 zipFunction) {
+        this.iterable = iterable;
+        this.zipFunction = zipFunction;
+    }
+
+    @Override
+    public Subscriber call(final Subscriber subscriber) {
+        final Iterator iterator = iterable.iterator();
+        try {
+            if (!iterator.hasNext()) {
+                subscriber.onCompleted();
+                return Subscribers.create();
+            }
+        } catch (Throwable e) {
+            subscriber.onError(e);
+        }
+        return new Subscriber() {
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onNext(T1 t) {
+                try {
+                    subscriber.onNext(zipFunction.call(t, iterator.next()));
+                    if (!iterator.hasNext()) {
+                        onCompleted();
+                    }
+                } catch (Throwable e) {
+                    onError(e);
+                }
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
new file mode 100644
index 0000000000..99e8296539
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
@@ -0,0 +1,339 @@
+/**
+ * Copyright 2014 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 static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import rx.Observable;
+import rx.Observer;
+import rx.operators.OperationReduceTest.CustomException;
+import rx.subjects.PublishSubject;
+import rx.util.functions.Func2;
+import rx.util.functions.Func3;
+
+public class OperatorZipIterableTest {
+    Func2 concat2Strings;
+    PublishSubject s1;
+    PublishSubject s2;
+    Observable zipped;
+
+    Observer observer;
+    InOrder inOrder;
+
+    @Before
+    @SuppressWarnings("unchecked")
+    public void setUp() {
+        concat2Strings = new Func2() {
+            @Override
+            public String call(String t1, String t2) {
+                return t1 + "-" + t2;
+            }
+        };
+
+        s1 = PublishSubject.create();
+        s2 = PublishSubject.create();
+        zipped = Observable.zip(s1, s2, concat2Strings);
+
+        observer = mock(Observer.class);
+        inOrder = inOrder(observer);
+
+        zipped.subscribe(observer);
+    }
+
+    Func2 zipr2 = new Func2() {
+
+        @Override
+        public String call(Object t1, Object t2) {
+            return "" + t1 + t2;
+        }
+
+    };
+    Func3 zipr3 = new Func3() {
+
+        @Override
+        public String call(Object t1, Object t2, Object t3) {
+            return "" + t1 + t2 + t3;
+        }
+
+    };
+
+    @Test
+    public void testZipIterableSameSize() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onNext("three-3");
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onError(any(Throwable.class));
+
+    }
+
+    @Test
+    public void testZipIterableEmptyFirstSize() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onCompleted();
+
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onError(any(Throwable.class));
+
+    }
+
+    @Test
+    public void testZipIterableEmptySecond() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList();
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testZipIterableFirstShorter() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onCompleted();
+
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onError(any(Throwable.class));
+
+    }
+
+    @Test
+    public void testZipIterableSecondShorter() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2");
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onNext("three-");
+        r1.onCompleted();
+
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onCompleted();
+
+        verify(o, never()).onError(any(Throwable.class));
+
+    }
+
+    @Test
+    public void testZipIterableFirstThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = Arrays.asList("1", "2", "3");
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onError(new OperationReduceTest.CustomException());
+
+        io.verify(o).onNext("one-1");
+        io.verify(o).onNext("two-2");
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+
+        verify(o, never()).onCompleted();
+
+    }
+
+    @Test
+    public void testZipIterableIteratorThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+            @Override
+            public Iterator iterator() {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onNext("two-");
+        r1.onError(new OperationReduceTest.CustomException());
+
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+
+        verify(o, never()).onCompleted();
+        verify(o, never()).onNext(any(String.class));
+
+    }
+
+    @Test
+    public void testZipIterableHasNextThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+
+            @Override
+            public Iterator iterator() {
+                return new Iterator() {
+                    int count;
+
+                    @Override
+                    public boolean hasNext() {
+                        if (count == 0) {
+                            return true;
+                        }
+                        throw new CustomException();
+                    }
+
+                    @Override
+                    public String next() {
+                        count++;
+                        return "1";
+                    }
+
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+
+                };
+            }
+
+        };
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onNext("one-");
+        r1.onError(new OperationReduceTest.CustomException());
+
+        io.verify(o).onNext("one-1");
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+
+        verify(o, never()).onCompleted();
+
+    }
+
+    @Test
+    public void testZipIterableNextThrows() {
+        PublishSubject r1 = PublishSubject.create();
+        /* define a Observer to receive aggregated events */
+        Observer o = mock(Observer.class);
+        InOrder io = inOrder(o);
+
+        Iterable r2 = new Iterable() {
+
+            @Override
+            public Iterator iterator() {
+                return new Iterator() {
+                    int count;
+
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+
+                    @Override
+                    public String next() {
+                        throw new CustomException();
+                    }
+
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+
+                };
+            }
+
+        };
+
+        r1.zip(r2, zipr2).subscribe(o);
+
+        r1.onError(new OperationReduceTest.CustomException());
+
+        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onCompleted();
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index bb40b6df9e..ad3b187687 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -766,265 +766,6 @@ public void testSecondFails() {
         inOrder.verifyNoMoreInteractions();
     }
 
-    @Test
-    public void testZipIterableSameSize() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList("1", "2", "3");
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onNext("three-");
-        r1.onCompleted();
-
-        io.verify(o).onNext("one-1");
-        io.verify(o).onNext("two-2");
-        io.verify(o).onNext("three-3");
-        io.verify(o).onCompleted();
-
-        verify(o, never()).onError(any(Throwable.class));
-
-    }
-
-    @Test
-    public void testZipIterableEmptyFirstSize() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList("1", "2", "3");
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onCompleted();
-
-        io.verify(o).onCompleted();
-
-        verify(o, never()).onNext(any(String.class));
-        verify(o, never()).onError(any(Throwable.class));
-
-    }
-
-    @Test
-    public void testZipIterableEmptySecond() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList();
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onNext("three-");
-        r1.onCompleted();
-
-        io.verify(o).onCompleted();
-
-        verify(o, never()).onNext(any(String.class));
-        verify(o, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testZipIterableFirstShorter() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList("1", "2", "3");
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onCompleted();
-
-        io.verify(o).onNext("one-1");
-        io.verify(o).onNext("two-2");
-        io.verify(o).onCompleted();
-
-        verify(o, never()).onError(any(Throwable.class));
-
-    }
-
-    @Test
-    public void testZipIterableSecondShorter() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList("1", "2");
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onNext("three-");
-        r1.onCompleted();
-
-        io.verify(o).onNext("one-1");
-        io.verify(o).onNext("two-2");
-        io.verify(o).onCompleted();
-
-        verify(o, never()).onError(any(Throwable.class));
-
-    }
-
-    @Test
-    public void testZipIterableFirstThrows() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = Arrays.asList("1", "2", "3");
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onError(new OperationReduceTest.CustomException());
-
-        io.verify(o).onNext("one-1");
-        io.verify(o).onNext("two-2");
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-
-        verify(o, never()).onCompleted();
-
-    }
-
-    @Test
-    public void testZipIterableIteratorThrows() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = new Iterable() {
-            @Override
-            public Iterator iterator() {
-                throw new OperationReduceTest.CustomException();
-            }
-        };
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onNext("two-");
-        r1.onError(new OperationReduceTest.CustomException());
-
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-
-        verify(o, never()).onCompleted();
-        verify(o, never()).onNext(any(String.class));
-
-    }
-
-    @Test
-    public void testZipIterableHasNextThrows() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = new Iterable() {
-
-            @Override
-            public Iterator iterator() {
-                return new Iterator() {
-                    int count;
-
-                    @Override
-                    public boolean hasNext() {
-                        if (count == 0) {
-                            return true;
-                        }
-                        throw new CustomException();
-                    }
-
-                    @Override
-                    public String next() {
-                        count++;
-                        return "1";
-                    }
-
-                    @Override
-                    public void remove() {
-                        throw new UnsupportedOperationException("Not supported yet.");
-                    }
-
-                };
-            }
-
-        };
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onNext("one-");
-        r1.onError(new OperationReduceTest.CustomException());
-
-        io.verify(o).onNext("one-1");
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-
-        verify(o, never()).onCompleted();
-
-    }
-
-    @Test
-    public void testZipIterableNextThrows() {
-        PublishSubject r1 = PublishSubject.create();
-        /* define a Observer to receive aggregated events */
-        Observer o = mock(Observer.class);
-        InOrder io = inOrder(o);
-
-        Iterable r2 = new Iterable() {
-
-            @Override
-            public Iterator iterator() {
-                return new Iterator() {
-                    int count;
-
-                    @Override
-                    public boolean hasNext() {
-                        return true;
-                    }
-
-                    @Override
-                    public String next() {
-                        throw new CustomException();
-                    }
-
-                    @Override
-                    public void remove() {
-                        throw new UnsupportedOperationException("Not supported yet.");
-                    }
-
-                };
-            }
-
-        };
-
-        r1.zip(r2, zipr2).subscribe(o);
-
-        r1.onError(new OperationReduceTest.CustomException());
-
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
-
-        verify(o, never()).onNext(any(String.class));
-        verify(o, never()).onCompleted();
-
-    }
-
     @Test
     public void testZipWithOnCompletedTwice() {
         // issue: https://groups.google.com/forum/#!topic/rxjava/79cWTv3TFp0

From 3d5474ff4bf1612cf585c478b7492a42683b3d93 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 4 Feb 2014 19:51:38 -0800
Subject: [PATCH 304/441] Zip NULL and COMPLETE Sentinels

---
 .../main/java/rx/operators/OperatorZip.java   | 24 ++++---
 .../java/rx/operators/OperatorZipTest.java    | 62 ++++++++++++++++++-
 2 files changed, 76 insertions(+), 10 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 00af87f6c4..802de494b5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -18,7 +18,6 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicLong;
 
-import rx.Notification;
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
@@ -131,6 +130,9 @@ private static class Zip {
         final FuncN zipFunction;
         final CompositeSubscription childSubscription = new CompositeSubscription();
 
+        static Object NULL_SENTINEL = new Object();
+        static Object COMPLETE_SENTINEL = new Object();
+
         @SuppressWarnings("rawtypes")
         public Zip(Observable[] os, final Subscriber observer, FuncN zipFunction) {
             this.os = os;
@@ -170,13 +172,16 @@ void tick() {
                     boolean allHaveValues = true;
                     for (int i = 0; i < observers.length; i++) {
                         vs[i] = ((InnerObserver) observers[i]).items.peek();
-                        if (vs[i] instanceof Notification) {
+                        if (vs[i] == NULL_SENTINEL) {
+                            // special handling for null
+                            vs[i] = null;
+                        } else if (vs[i] == COMPLETE_SENTINEL) {
+                            // special handling for onComplete
                             observer.onCompleted();
                             // we need to unsubscribe from all children since children are independently subscribed
                             childSubscription.unsubscribe();
                             return;
-                        }
-                        if (vs[i] == null) {
+                        } else if (vs[i] == null) {
                             allHaveValues = false;
                             // we continue as there may be an onCompleted on one of the others
                             continue;
@@ -189,7 +194,7 @@ void tick() {
                         for (int i = 0; i < observers.length; i++) {
                             ((InnerObserver) observers[i]).items.poll();
                             // eagerly check if the next item on this queue is an onComplete
-                            if (((InnerObserver) observers[i]).items.peek() instanceof Notification) {
+                            if (((InnerObserver) observers[i]).items.peek() == COMPLETE_SENTINEL) {
                                 // it is an onComplete so shut down
                                 observer.onCompleted();
                                 // we need to unsubscribe from all children since children are independently subscribed
@@ -213,7 +218,7 @@ final class InnerObserver extends Subscriber {
             @SuppressWarnings("unchecked")
             @Override
             public void onCompleted() {
-                items.add(Notification.createOnCompleted());
+                items.add(COMPLETE_SENTINEL);
                 tick();
             }
 
@@ -226,8 +231,11 @@ public void onError(Throwable e) {
             @SuppressWarnings("unchecked")
             @Override
             public void onNext(Object t) {
-                // TODO use a placeholder for NULL, such as Notification(null)
-                items.add(t);
+                if (t == null) {
+                    items.add(NULL_SENTINEL);
+                } else {
+                    items.add(t);
+                }
                 tick();
             }
         };
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index ad3b187687..f20b5caab2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -22,7 +22,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -32,12 +31,12 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.Notification;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.operators.OperationReduceTest.CustomException;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action1;
@@ -928,6 +927,65 @@ public void onNext(String s) {
         assertEquals("5-5", list.get(4));
     }
 
+    @Test
+    public void testEmitNull() {
+        Observable oi = Observable.from(1, null, 3);
+        Observable os = Observable.from("a", "b", null);
+        Observable o = Observable.zip(oi, os, new Func2() {
+
+            @Override
+            public String call(Integer t1, String t2) {
+                return t1 + "-" + t2;
+            }
+
+        });
+
+        final ArrayList list = new ArrayList();
+        o.subscribe(new Action1() {
+
+            @Override
+            public void call(String s) {
+                System.out.println(s);
+                list.add(s);
+            }
+        });
+
+        assertEquals(3, list.size());
+        assertEquals("1-a", list.get(0));
+        assertEquals("null-b", list.get(1));
+        assertEquals("3-null", list.get(2));
+    }
+
+    @Test
+    public void testEmitMaterializedNotifications() {
+        Observable> oi = Observable.from(1, 2, 3).materialize();
+        Observable> os = Observable.from("a", "b", "c").materialize();
+        Observable o = Observable.zip(oi, os, new Func2, Notification, String>() {
+
+            @Override
+            public String call(Notification t1, Notification t2) {
+                return t1.getKind() + "_" + t1.getValue() + "-" + t2.getKind() + "_" + t2.getValue();
+            }
+
+        });
+
+        final ArrayList list = new ArrayList();
+        o.subscribe(new Action1() {
+
+            @Override
+            public void call(String s) {
+                System.out.println(s);
+                list.add(s);
+            }
+        });
+
+        assertEquals(4, list.size());
+        assertEquals("OnNext_1-OnNext_a", list.get(0));
+        assertEquals("OnNext_2-OnNext_b", list.get(1));
+        assertEquals("OnNext_3-OnNext_c", list.get(2));
+        assertEquals("OnCompleted_null-OnCompleted_null", list.get(3));
+    }
+
     Observable OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger());
 
     Observable OBSERVABLE_OF_5_INTEGERS(final AtomicInteger numEmitted) {

From f023a10bfd22182c28c605e3f4b5c698e53978b2 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 15:34:31 +0100
Subject: [PATCH 305/441] Fixed OperationSubscribeOn so
 OperationConditionalsTest works again.

---
 .../src/main/java/rx/operators/OperationSubscribeOn.java        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
index 5f1329bda5..586d9c4287 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
@@ -84,7 +84,7 @@ public void unsubscribe() {
                 public void call(Inner inner) {
                     underlying.unsubscribe();
                     // tear down this subscription as well now that we're done
-                    inner.unsubscribe();
+//                    inner.unsubscribe();
                 }
             });
         }

From 0f92fdd8e6422d5b79c610a7fd8409d222315a49 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 16:44:01 +0100
Subject: [PATCH 306/441] RunAsync method for outputting multiple values

---
 .../src/main/java/rx/util/async/Async.java    | 56 +++++++++++++++++++
 .../rx/util/async/StoppableObservable.java    | 41 ++++++++++++++
 .../test/java/rx/util/async/AsyncTest.java    | 46 ++++++++++++++-
 3 files changed, 142 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/StoppableObservable.java

diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index e091e78a9c..4f04f5fb47 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -20,10 +20,16 @@
 import java.util.concurrent.FutureTask;
 
 import rx.Observable;
+import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.Subscription;
 import rx.schedulers.Schedulers;
 import rx.subjects.AsyncSubject;
+import rx.subjects.PublishSubject;
+import rx.subjects.Subject;
+import rx.subscriptions.SerialSubscription;
 import rx.util.async.operators.Functionals;
 import rx.util.async.operators.OperationDeferFuture;
 import rx.util.async.operators.OperationForEachFuture;
@@ -1711,4 +1717,54 @@ public static  Observable fromCallable(Callable callable, Sch
     public static  Observable fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
         return Observable.create(OperationFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);
     }
+    /**
+     * Runs the provided action on the given scheduler and allows propagation
+     * of multiple events to the observers of the returned StoppableObservable.
+     * The action is immediately executed and unobserved values will be lost.
+     * @param  the output value type
+     * @param scheduler the scheduler where the action is executed
+     * @param action the action to execute, receives an Observer where the events can be pumped
+     *               and a Subscription which lets check for cancellation condition.
+     * @return an Observable which provides a Subscription interface to cancel the action
+     */
+    public static  StoppableObservable runAsync(Scheduler scheduler, 
+            final Action2, ? super Subscription> action) {
+        return runAsync(scheduler, PublishSubject.create(), action);
+    }
+    /**
+     * Runs the provided action on the given scheduler and allows propagation
+     * of multiple events to the observers of the returned StoppableObservable.
+     * The action is immediately executed and unobserved values might be lost,
+     * depending on the subject type used.
+     * @param  the output value of the action
+     * @param  the output type of the observable sequence
+     * @param scheduler the scheduler where the action is executed
+     * @param subject the subject to use to distribute values emitted by the action
+     * @param action the action to execute, receives an Observer where the events can be pumped
+     *               and a Subscription which lets check for cancellation condition.
+     * @return an Observable which provides a Subscription interface to cancel the action
+     */
+    public static  StoppableObservable runAsync(Scheduler scheduler,
+            final Subject subject, 
+            final Action2, ? super Subscription> action) {
+        final SerialSubscription csub = new SerialSubscription();
+        
+        StoppableObservable co = new StoppableObservable(new Observable.OnSubscribe() {
+            @Override
+            public void call(Subscriber t1) {
+                subject.subscribe(t1);
+            }
+        }, csub);
+        
+        csub.set(scheduler.schedule(new Action1() {
+            @Override
+            public void call(Inner t1) {
+                if (!csub.isUnsubscribed()) {
+                    action.call(subject, csub);
+                }
+            }
+        }));
+        
+        return co;
+    }
 }
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/StoppableObservable.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/StoppableObservable.java
new file mode 100644
index 0000000000..ebd9538ed5
--- /dev/null
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/StoppableObservable.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright 2014 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.util.async;
+
+import rx.Observable;
+import rx.Subscription;
+
+/**
+ * An Observable which provides a Subscription interface to signal a stop
+ * condition to an asynchronous task.
+ */
+public class StoppableObservable extends Observable implements Subscription {
+    private final Subscription token;
+    public StoppableObservable(Observable.OnSubscribe onSubscribe, Subscription token) {
+        super(onSubscribe);
+        this.token = token;
+    }
+    
+    @Override
+    public boolean isUnsubscribed() {
+        return token.isUnsubscribed();
+    }
+    
+    @Override
+    public void unsubscribe() {
+        token.unsubscribe();
+    }
+}
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
index d83d01b047..3146681c5f 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
@@ -16,8 +16,8 @@
 
 package rx.util.async;
 
+import java.util.concurrent.CountDownLatch;
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
@@ -35,6 +35,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscription;
 import rx.observers.TestObserver;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
@@ -818,4 +819,47 @@ public String answer(InvocationOnMock invocation) throws Throwable {
         verify(func, times(1)).call();
     }
 
+    @Test
+    public void testRunAsync() throws InterruptedException {
+        final CountDownLatch cdl = new CountDownLatch(1);
+        final CountDownLatch cdl2 = new CountDownLatch(1);
+        Action2, Subscription> action = new Action2, Subscription>() {
+            @Override
+            public void call(Observer t1, Subscription t2) {
+                try {
+                    cdl.await();
+                } catch (InterruptedException ex) {
+                    Thread.currentThread().interrupt();
+                    return;
+                }
+                for (int i = 0; i < 10 && !t2.isUnsubscribed(); i++) {
+                    t1.onNext(i);
+                }
+                t1.onCompleted();
+                cdl2.countDown();
+            }
+        };
+        
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        StoppableObservable so = Async.runAsync(Schedulers.io(), action);
+        
+        so.subscribe(o);
+        
+        cdl.countDown();
+        
+        if (!cdl2.await(2, TimeUnit.SECONDS)) {
+            fail("Didn't complete");
+        }
+        
+        for (int i = 0; i < 10; i++) {
+            inOrder.verify(o).onNext(i);
+        }
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
 }

From 8996277fb740deb7c5e15c4e959e6b9caed00bb0 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter 
Date: Wed, 5 Feb 2014 17:42:13 +0100
Subject: [PATCH 307/441] one global onCompleted object

---
 rxjava-core/src/main/java/rx/Notification.java | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Notification.java b/rxjava-core/src/main/java/rx/Notification.java
index bf7ebb1881..df3e22b3a2 100644
--- a/rxjava-core/src/main/java/rx/Notification.java
+++ b/rxjava-core/src/main/java/rx/Notification.java
@@ -26,6 +26,8 @@ public class Notification {
     private final Throwable throwable;
     private final T value;
 
+    private static final Notification ON_COMPLETED = new Notification(Kind.OnCompleted, null, null);
+
     public static  Notification createOnNext(T t) {
         return new Notification(Kind.OnNext, t, null);
     }
@@ -34,12 +36,14 @@ public static  Notification createOnError(Throwable e) {
         return new Notification(Kind.OnError, null, e);
     }
 
+    @SuppressWarnings("unchecked")
     public static  Notification createOnCompleted() {
-        return new Notification(Kind.OnCompleted, null, null);
+        return (Notification) ON_COMPLETED;
     }
 
+    @SuppressWarnings("unchecked")
     public static  Notification createOnCompleted(Class type) {
-        return new Notification(Kind.OnCompleted, null, null);
+        return (Notification) ON_COMPLETED;
     }
 
     private Notification(Kind kind, T value, Throwable e) {

From 00ca382f7fc4d51019a1a27793e043c6b404e195 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Wed, 5 Feb 2014 10:14:37 -0800
Subject: [PATCH 308/441] Updates some javadoc comments to reflect 0.17 changes

---
 rxjava-core/src/main/java/rx/Observable.java | 87 +++++++-------------
 1 file changed, 28 insertions(+), 59 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 872460b43d..3a2dad469e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -162,11 +162,11 @@ public class Observable {
     /**
      * Observable with Function to execute when subscribed to.
      * 
    
-     * Note: Use {@link #create(OnSubscribeFunc)} to create an Observable, instead of this
+     * Note: Use {@link #create(OnSubscribe)} 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(Subscriber)} is called
+     * @param f
+     *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
      */
     protected Observable(OnSubscribe f) {
         this.f = f;
@@ -175,14 +175,16 @@ protected Observable(OnSubscribe f) {
     private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
     /**
-     * Returns an Observable that will execute the specified function when an {@link Subscriber} subscribes to it.
+     * Returns an Observable that will execute the specified function when a {@link Subscriber}
+     * subscribes to it.
      * 
    
      * 
      * 
    
      * Write the function you pass to {@code create} so that it behaves as an Observable: It should
-     * invoke the Observer's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError}, and {@link Subscriber#onCompleted onCompleted} methods appropriately.
+     * invoke the Subscriber's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError},
+     * and {@link Subscriber#onCompleted onCompleted} methods appropriately.
      * 
    
-     * A well-formed Observable must invoke either the Observer's {@code onCompleted} method
+     * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method
      * exactly once or its {@code onError} method exactly once.
      * 
    
      * See Rx Design Guidelines (PDF)
@@ -190,10 +192,10 @@ protected Observable(OnSubscribe f) {
      * 
      * @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} that
-     *            allows the Observer to cancel the subscription
-     * @return an Observable that, when an {@link Subscriber} subscribes to it, will execute the
+     * @param f
+     *            a function that accepts an {@code Subscriber}, and invokes its {@code onNext},
+     *            {@code onError}, and {@code onCompleted} methods as appropriate
+     * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the
      *         specified function
      * @see RxJava Wiki: create()
      * @see MSDN: Observable.Create
@@ -202,10 +204,16 @@ public final static  Observable create(OnSubscribe f) {
         return new Observable(f);
     }
 
+    /**
+     * 
+     */
     public static interface OnSubscribe extends Action1> {
 
     }
 
+    /**
+     * 
+     */
     public final static  Observable create(final OnSubscribeFunc f) {
         return new Observable(new OnSubscribe() {
 
@@ -220,6 +228,9 @@ public void call(Subscriber observer) {
         });
     }
 
+    /**
+     * 
+     */
     public static interface OnSubscribeFunc extends Function {
 
         public Subscription onSubscribe(Observer op);
@@ -1025,7 +1036,7 @@ public final static  Observable concat(Observable t1, Observa
     /**
      * Returns an Observable that calls an Observable factory to create its Observable for each new
      * Observer that subscribes. That is, for each subscriber, the actual Observable that subscriber
-     * observs is determined by the factory function.
+     * observes is determined by the factory function.
      * 
    
      * 
      * 
    
@@ -1194,9 +1205,6 @@ public final static  Observable from(Future future, Scheduler
      * sequence.
      * 
    
      * 
-     * 
    
-     * Note: the entire iterable sequence is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible
-     * to unsubscribe from the sequence before it completes.
      * 
      * @param iterable
      *            the source {@link Iterable} sequence
@@ -1236,10 +1244,6 @@ public final static  Observable from(Iterable iterable, Sched
      * Converts an item into an Observable that emits that item.
      * 
    
      * 
-     * 
    
-     * Note: the item is immediately emitted each time an {@link Observer} subscribes. Since this
-     * occurs before the {@link Subscription} is returned, it is not possible to unsubscribe from
-     * the sequence before it completes.
      * 
      * @param t1
      *            the item
@@ -1257,10 +1261,6 @@ public final static  Observable from(T t1) {
      * Converts two items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1282,10 +1282,6 @@ public final static  Observable from(T t1, T t2) {
      * Converts three items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1309,10 +1305,6 @@ public final static  Observable from(T t1, T t2, T t3) {
      * Converts four items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1338,10 +1330,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4) {
      * Converts five items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1369,10 +1357,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5) {
      * Converts six items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1402,10 +1386,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6) {
      * Converts seven items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1437,10 +1417,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * Converts eight items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1474,10 +1450,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * Converts nine items into an Observable that emits those items.
      * 
    
      * 
-     * 
    
-     * Note: the items will be immediately emitted each time an {@link Observer} subscribes. Since
-     * this occurs before the {@link Subscription} is returned, it is not possible to unsubscribe
-     * from the sequence before it completes.
      * 
      * @param t1
      *            first item
@@ -1551,9 +1523,6 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * Converts an Array into an Observable that emits the items in the Array.
      * 
    
      * 
-     * 
    
-     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not possible
-     * to unsubscribe from the sequence before it completes.
      * 
      * @param items
      *            the source array
@@ -1573,9 +1542,6 @@ public final static  Observable from(T... t1) {
      * scheduler.
      * 
    
      * 
-     * 
    
-     * Note: the entire array is immediately emitted each time an {@link Observer} subscribes. Since this occurs before the {@link Subscription} is returned, it is not
-     * possible to unsubscribe from the sequence before it completes.
      * 
      * @param items
      *            the source array
@@ -3805,12 +3771,15 @@ public final  Observable> buffer(Observable boundary, int initialC
      * 
      * 
    
      * 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.
+     * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
      * 
    
      * When you call {@code cache()}, it does not yet subscribe to the source Observable. This only
-     * happens when {@code subscribe} is called the first time on the Observable returned by {@code cache()}.
+     * happens when {@code subscribe} is called the first time on the Observable returned by
+     * {@code cache()}.
      * 
    
-     * Note: You sacrifice the ability to unsubscribe from the origin when you use the {@code cache()} Observer so be careful not to use this Observer on Observables that emit an
+     *                             
+     * Note: You sacrifice the ability to unsubscribe from the origin when you use the
+     * {@code cache()} Observer so be careful not to use this Observer 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 items and

From f6fe8e7a5c2725d0a9858b05897ead4d21c19a47 Mon Sep 17 00:00:00 2001
From: headinthebox 
Date: Wed, 5 Feb 2014 20:35:23 +0100
Subject: [PATCH 309/441] - Updated schedulers to reflext 0.17 changes. - Add
 timer bindings

---
 gradle/wrapper/gradle-wrapper.properties      |   4 +-
 .../scala/rx/lang/scala/JavaConversions.scala |   5 +-
 .../scala/rx/lang/scala/Notification.scala    |   6 +-
 .../main/scala/rx/lang/scala/Observable.scala |  43 +++-
 .../main/scala/rx/lang/scala/Scheduler.scala  | 194 +++++-------------
 .../schedulers/ComputationScheduler.scala     |  25 +++
 .../schedulers/CurrentThreadScheduler.scala   |  31 ---
 .../scala/schedulers/ExecutorScheduler.scala  |   7 +-
 ...ForIOScheduler.scala => IOScheduler.scala} |  22 +-
 .../scala/schedulers/NewThreadScheduler.scala |   3 +-
 .../ScheduledExecutorServiceScheduler.scala   |  33 ---
 .../lang/scala/schedulers/TestScheduler.scala |   3 +-
 .../ThreadPoolForComputationScheduler.scala   |  37 ----
 .../schedulers/TrampolineScheduler.scala      |  15 ++
 settings.gradle                               |   2 +-
 15 files changed, 161 insertions(+), 269 deletions(-)
 create mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
 delete mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala
 rename language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/{ThreadPoolForIOScheduler.scala => IOScheduler.scala} (58%)
 delete mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala
 delete mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala
 create mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TrampolineScheduler.scala

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2c79588016..8368385b1b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Tue Sep 03 10:20:57 PDT 2013
+#Wed Feb 05 12:05:54 CET 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-all.zip
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala
index f36dc6b6dd..d003842be4 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/JavaConversions.scala
@@ -33,9 +33,12 @@ object JavaConversions {
   implicit def toScalaSubscription(s: rx.Subscription): Subscription = Subscription(s)
 
   implicit def scalaSchedulerToJavaScheduler(s: Scheduler): rx.Scheduler = s.asJavaScheduler
-  
   implicit def javaSchedulerToScalaScheduler(s: rx.Scheduler): Scheduler = Scheduler(s)
 
+  implicit def scalaInnerToJavaInner(s: Inner): rx.Scheduler.Inner = s.asJavaInner
+  implicit def javaInnerToScalaInner(s: rx.Scheduler.Inner): Inner = Inner(s)
+
+
   implicit def toJavaObserver[T](s: Observer[T]): rx.Observer[_ >: T] = s.asJavaObserver
   
   implicit def toScalaObserver[T](s: rx.Observer[_ >: T]): Observer[T] = Observer(s)
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
index 616fff22c2..c03ead4a4f 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
@@ -98,7 +98,7 @@ object Notification {
      * The item passed to the onNext method.
      */
     def apply[T](value: T): Notification[T] = {
-      Notification(new rx.Notification[T](value))
+      Notification(rx.Notification.createOnNext[T](value))
     }
 
     /**
@@ -128,7 +128,7 @@ object Notification {
      * The exception passed to the onNext method.
      */
     def apply[T](error: Throwable): Notification[T] = {
-      Notification(new rx.Notification[T](error))
+      Notification(rx.Notification.createOnError[T](error))
     }
 
     /**
@@ -156,7 +156,7 @@ object Notification {
      * Constructor for onCompleted notifications.
      */
     def apply[T](): Notification[T] = {
-      Notification(new rx.Notification())
+      Notification(rx.Notification.createOnCompleted[T]())
     }
 
     /**
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index 13b20cc1e5..f9a5b3fb23 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -19,6 +19,7 @@ package rx.lang.scala
 import rx.util.functions.FuncN
 import rx.Observable.OnSubscribeFunc
 import rx.lang.scala.observables.ConnectableObservable
+import scala.concurrent.duration
 
 
 /**
@@ -2342,17 +2343,53 @@ object Observable {
    *
    * 
    *
-   * @param duration
+   * @param period
    *            duration between two consecutive numbers
    * @param scheduler
    *            the scheduler to use
    * @return An Observable that emits a number each time interval.
    */
-  def interval(duration: Duration, scheduler: Scheduler): Observable[Long] = {
-    toScalaObservable[java.lang.Long](rx.Observable.interval(duration.length, duration.unit, scheduler)).map(_.longValue())
+  def interval(period: Duration, scheduler: Scheduler): Observable[Long] = {
+    toScalaObservable[java.lang.Long](rx.Observable.interval(period.length, period.unit, scheduler)).map(_.longValue())
+  }
+
+  /**
+   * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
+   * numbers after each {@code period} of time thereafter, on a specified Scheduler.
+   * 
    
+   * 
+   *
+   * @param initialDelay
+   * the initial delay time to wait before emitting the first value of 0L
+   * @param period
+   * the period of time between emissions of the subsequent numbers
+   * @return an Observable that emits a 0L after the { @code initialDelay} and ever increasing
+   *                                                         numbers after each { @code period} of time thereafter, while running on the given { @code scheduler}
+   */
+  def timer(initialDelay: Duration, period: Duration): Observable[Long] = {
+    toScalaObservable[java.lang.Long](rx.Observable.timer(initialDelay.toNanos, period.toNanos, duration.NANOSECONDS)).map(_.longValue())
     /*XXX*/
   }
 
+  /**
+   * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
+   * numbers after each {@code period} of time thereafter, on a specified Scheduler.
+   * 
    
+   * 
+   *
+   * @param initialDelay
+   * the initial delay time to wait before emitting the first value of 0L
+   * @param period
+   * the period of time between emissions of the subsequent numbers
+   * @param scheduler
+     * the scheduler on which the waiting happens and items are emitted
+   * @return an Observable that emits a 0L after the { @code initialDelay} and ever increasing
+   *                                                         numbers after each { @code period} of time thereafter, while running on the given { @code scheduler}
+   */
+  def timer(initialDelay: Duration, period: Duration, scheduler: Scheduler): Observable[Long] = {
+    toScalaObservable[java.lang.Long](rx.Observable.timer(initialDelay.toNanos, period.toNanos, duration.NANOSECONDS, scheduler)).map(_.longValue())
+  }
+
 }
 
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
index ead8054279..db82612c6f 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
@@ -15,199 +15,107 @@
  */
 package rx.lang.scala
 
-import java.util.Date
 import scala.concurrent.duration.Duration
-import rx.util.functions.{Action0, Action1, Func2}
+import rx.util.functions.Action1
 import rx.lang.scala.schedulers._
+import scala.concurrent.duration
+import rx.lang.scala.JavaConversions._
 
 /**
  * Represents an object that schedules units of work.
  */
 trait Scheduler {
-  import rx.lang.scala.ImplicitFunctionConversions._
 
   private [scala] val asJavaScheduler: rx.Scheduler
 
   /**
-   * Schedules a cancelable action to be executed.
+   * Parallelism available to a Scheduler.
    *
-   * @param action Action to schedule.
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  def schedule(action: Scheduler => Subscription): Subscription = {
-    this.schedule[Integer](0, (s: Scheduler, x: Integer) => action(s): Subscription): Subscription
-  }
-
-  /**
-   * Schedules a cancelable action to be executed.
+   * This defaults to {@code Runtime.getRuntime().availableProcessors()} but can be overridden for use cases such as scheduling work on a computer cluster.
    *
-   * @param state State to pass into the action.
-   * @param action Action to schedule.
-   * @return a subscription to be able to unsubscribe from action.
+   * @return the scheduler's available degree of parallelism.
    */
-  private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription): Subscription = {
-    Subscription(asJavaScheduler.schedule(state, new Func2[rx.Scheduler, T, rx.Subscription] {
-      def call(t1: rx.Scheduler, t2: T): rx.Subscription = {
-        action(Scheduler(t1), t2).asJavaSubscription
-      }
-    }))
-  }
+  def degreeOfParallelism: Int =  asJavaScheduler.degreeOfParallelism
 
   /**
-   * Schedules a cancelable action to be executed in delayTime.
-   *
-   * @param action Action to schedule.
-   * @param delayTime  Time the action is to be delayed before executing.
-   * @return a subscription to be able to unsubscribe from action.
+   * @return the scheduler's notion of current absolute time in milliseconds.
    */
-  def schedule(delayTime: Duration, action: Scheduler => Subscription): Subscription = {
-    this.schedule[Integer](0, (s: Scheduler, x: Integer) => action(s), delayTime: Duration): Subscription
-  }
+  def now: Long = this.asJavaScheduler.now()
 
   /**
-   * Schedules a cancelable action to be executed in delayTime.
+   * Schedules a cancelable action to be executed.
    *
-   * @param state
-   *            State to pass into the action.
-   * @param action
-   *            Action to schedule.
-   * @param delayTime
-   *            Time the action is to be delayed before executing.
+   * @param action Action to schedule.
    * @return a subscription to be able to unsubscribe from action.
    */
-  private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription, delayTime: Duration): Subscription = {
-    Subscription(asJavaScheduler.schedule(state, schedulerActionToFunc2(action), delayTime.length, delayTime.unit))
-  }
-
-  /**
-   * Schedules a cancelable action to be executed periodically.
-   * This default implementation schedules recursively and waits for actions to complete (instead of potentially executing
-   * long-running actions concurrently). Each scheduler that can do periodic scheduling in a better way should override this.
-   *
-   * @param action The action to execute periodically.
-   * @param initialDelay Time to wait before executing the action for the first time.
-   * @param period The time interval to wait each time in between executing the action.
-   * @return A subscription to be able to unsubscribe from action.
-   */
-  def schedule(initialDelay: Duration, period: Duration, action: Scheduler => Subscription): Subscription = {
-    this.schedulePeriodically[Integer](0, (s: Scheduler, x:Integer) => action(s): Subscription, initialDelay: Duration, period: Duration): Subscription
-  }
+  def schedule(action: Inner => Unit): Subscription = this.asJavaScheduler.schedule(action)
 
   /**
    * Schedules a cancelable action to be executed periodically.
    * This default implementation schedules recursively and waits for actions to complete (instead of potentially executing
    * long-running actions concurrently). Each scheduler that can do periodic scheduling in a better way should override this.
    *
-   * @param state
-   *            State to pass into the action.
    * @param action
-   *            The action to execute periodically.
+   * The action to execute periodically.
    * @param initialDelay
-   *            Time to wait before executing the action for the first time.
+   * Time to wait before executing the action for the first time.
    * @param period
-   *            The time interval to wait each time in between executing the action.
+   * The time interval to wait each time in between executing the action.
    * @return A subscription to be able to unsubscribe from action.
    */
-  private [scala] def schedulePeriodically[T](state: T, action: (Scheduler, T) => Subscription, initialDelay: Duration, period: Duration): Subscription = {
-    Subscription(asJavaScheduler.schedulePeriodically(state, action, initialDelay.length, initialDelay.unit.convert(period.length, period.unit), initialDelay.unit))
-  }
-
-  /**
-   * Schedules a cancelable action to be executed at dueTime.
-   *
-   * @param action Action to schedule.
-   * @param dueTime Time the action is to be executed. If in the past it will be executed immediately.
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  def schedule(dueTime: Date, action: Scheduler => Subscription): Subscription = {
-    this.schedule(0: Integer, (s: Scheduler, x: Integer) => action(s): Subscription, dueTime: Date): Subscription
-  }
+  def schedulePeriodically(action: Inner => Unit, initialDelay: Duration, period: Duration): Subscription =
+     this.asJavaScheduler.schedulePeriodically (
+       new Action1[rx.Scheduler.Inner] {
+         override def call(inner: rx.Scheduler.Inner): Unit = action(javaInnerToScalaInner(inner))
+       },
+       initialDelay.toNanos,
+       period.toNanos,
+       duration.NANOSECONDS
+     )
 
-  /**
-   * Schedules a cancelable action to be executed at dueTime.
-   *
-   * @param state
-   *            State to pass into the action.
-   * @param action
-   *            Action to schedule.
-   * @param dueTime
-   *            Time the action is to be executed. If in the past it will be executed immediately.
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  private [scala] def schedule[T](state: T, action: (Scheduler, T) => Subscription, dueTime: Date): Subscription = {
-    Subscription(asJavaScheduler.schedule(state, action, dueTime))
+  def scheduleRec(work: (=>Unit)=>Unit): Subscription = {
+    Subscription(asJavaScheduler.schedule(new Action1[rx.Scheduler.Inner] {
+      override def call(inner: rx.Scheduler.Inner): Unit =  work{ inner.schedule(this) }
+    }))
   }
+}
 
-  /**
-   * Schedules an action to be executed.
-   *
-   * @param action
-   *            action
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  def schedule(action: =>Unit): Subscription = {
-    Subscription(asJavaScheduler.schedule(()=>action))
-  }
+object Inner {
+  def apply(inner: rx.Scheduler.Inner): Inner = new Inner { private[scala] val asJavaInner = inner }
+}
 
-  /**
-   * Schedules an action to be executed in delayTime.
-   *
-   * @param action action
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  def schedule(delayTime: Duration, action: =>Unit): Subscription = {
-    Subscription(asJavaScheduler.schedule(()=>action, delayTime.length, delayTime.unit))
-  }
+trait Inner extends Subscription {
+  private [scala] val asJavaInner: rx.Scheduler.Inner
 
   /**
-   * Schedules an action to be executed periodically.
-   *
-   * @param action
-   *            The action to execute periodically.
-   * @param initialDelay
-   *            Time to wait before executing the action for the first time.
-   * @param period
-   *            The time interval to wait each time in between executing the action.
-   * @return A subscription to be able to unsubscribe from action.
+   * Schedules a cancelable action to be executed in delayTime.
    */
-  def schedule(initialDelay: Duration, period: Duration, action: =>Unit): Subscription = {
-    Subscription(asJavaScheduler.schedulePeriodically(()=>action, initialDelay.length, initialDelay.unit.convert(period.length, period.unit), initialDelay.unit))
-  }
-
-  def scheduleRec(work: (=>Unit)=>Unit): Subscription = {
-    Subscription(asJavaScheduler.schedule(new Action1[Action0] {
-      def call(t1: Action0){
-        work{ t1.call() }
-      }
-    }))
-  }
+  def schedule(action: Inner => Unit, delayTime: Duration): Unit =
+    this.asJavaInner.schedule(
+      new Action1[rx.Scheduler.Inner] {
+        override def call(inner: rx.Scheduler.Inner): Unit = action(javaInnerToScalaInner(inner))
+      },
+      delayTime.length,
+      delayTime.unit)
 
   /**
-   * Returns the scheduler's notion of current absolute time in milliseconds.
+   * Schedules a cancelable action to be executed immediately.
    */
-  def now: Long = {
-    asJavaScheduler.now
-  }
+  def schedule(action: Inner=>Unit): Unit = this.asJavaInner.schedule(
+    new Action1[rx.Scheduler.Inner]{
+      override def call(inner: rx.Scheduler.Inner): Unit = action(javaInnerToScalaInner(inner))
+    }
+  )
 
   /**
-   * Parallelism available to a Scheduler.
-   *
-   * This defaults to {@code Runtime.getRuntime().availableProcessors()} but can be overridden for use cases such as scheduling work on a computer cluster.
-   *
-   * @return the scheduler's available degree of parallelism.
+   * @return the scheduler's notion of current absolute time in milliseconds.
    */
-  def degreeOfParallelism: Int = {
-    asJavaScheduler.degreeOfParallelism
-  }
-
+  def now: Long = this.asJavaInner.now()
 }
 
+
 private [scala] object Scheduler {
   def apply(scheduler: rx.Scheduler): Scheduler = scheduler match {
-    case s: rx.schedulers.CurrentThreadScheduler => new CurrentThreadScheduler(s)
-    case s: rx.schedulers.ExecutorScheduler => new ExecutorScheduler(s)
-    case s: rx.schedulers.ImmediateScheduler => new ImmediateScheduler(s)
-    case s: rx.schedulers.NewThreadScheduler => new NewThreadScheduler(s)
     case s: rx.schedulers.TestScheduler => new TestScheduler(s)
     case s: rx.Scheduler => new Scheduler{ val asJavaScheduler = s }
   }
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
new file mode 100644
index 0000000000..8c2eeda134
--- /dev/null
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
@@ -0,0 +1,25 @@
+package rx.lang.scala.schedulers
+
+import rx.lang.scala.Scheduler
+
+
+object ComputationScheduler {
+  /**
+   * {@link Scheduler} intended for computational work.
+   * 
    
+   * This can be used for event-loops, processing callbacks and other computational work.
+   * 
    
+   * Do not perform IO-bound work on this scheduler. Use {@link IOScheduler()} instead.
+   *
+   * @return { @link Scheduler} for computation-bound work.
+   */
+  def apply(): IOScheduler = {
+    new IOScheduler(rx.schedulers.Schedulers.computation())
+  }
+}
+
+/**
+ * Created by netflix on 2/5/14.
+ */
+class ComputationScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
+  extends Scheduler {}
\ No newline at end of file
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala
deleted file mode 100644
index 688b1e86ca..0000000000
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/CurrentThreadScheduler.scala
+++ /dev/null
@@ -1,31 +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.lang.scala.schedulers
-
-import rx.lang.scala.Scheduler
-
-object CurrentThreadScheduler {
-
-  /**
-   * Returns a [[rx.lang.scala.Scheduler]] that queues work on the current thread to be executed after the current work completes.
-   */
-  def apply(): CurrentThreadScheduler =  {
-    new CurrentThreadScheduler(rx.schedulers.Schedulers.currentThread())
-  }
-}
-
-class CurrentThreadScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
-  extends Scheduler {}
\ No newline at end of file
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala
index 72287939e8..0ffe30b2a2 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala
@@ -15,7 +15,7 @@
  */
 package rx.lang.scala.schedulers
 
-import java.util.concurrent.Executor
+import java.util.concurrent.{ScheduledExecutorService, Executor}
 import rx.lang.scala.Scheduler
 
 object ExecutorScheduler {
@@ -28,8 +28,11 @@ object ExecutorScheduler {
   def apply(executor: Executor): ExecutorScheduler =  {
     new ExecutorScheduler(rx.schedulers.Schedulers.executor(executor))
   }
-}
 
+  def apply(executor: ScheduledExecutorService): ExecutorScheduler =  {
+    new ExecutorScheduler(rx.schedulers.Schedulers.executor(executor))
+  }
+}
 
 class ExecutorScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
   extends Scheduler {}
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
similarity index 58%
rename from language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala
rename to language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
index e3fef92080..b7453016cf 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForIOScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
@@ -17,21 +17,23 @@ package rx.lang.scala.schedulers
 
 import rx.lang.scala.Scheduler
 
-object ThreadPoolForIOScheduler {
-
+object IOScheduler {
   /**
-   * [[rx.lang.scala.Scheduler]] intended for IO-bound work.
-   *
-   * The implementation is backed by an `java.util.concurrent.Executor` thread-pool that will grow as needed.
-   *
+   * {@link Scheduler} intended for IO-bound work.
+   * 
    
+   * The implementation is backed by an {@link Executor} thread-pool that will grow as needed.
+   * 
    
    * This can be used for asynchronously performing blocking IO.
+   * 
    
+   * Do not perform computational work on this scheduler. Use {@link ComputationScheduler()} instead.
    *
-   * Do not perform computational work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForComputationScheduler]] instead.
+   * @return { @link ExecutorScheduler} for IO-bound work.
    */
-  def apply(): ThreadPoolForIOScheduler = {
-    new ThreadPoolForIOScheduler(rx.schedulers.Schedulers.threadPoolForIO())
+  def apply(): IOScheduler = {
+    new IOScheduler(rx.schedulers.Schedulers.io)
   }
 }
 
-class ThreadPoolForIOScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
+class IOScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
   extends Scheduler {}
+
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala
index 1955035981..e24450f89a 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/NewThreadScheduler.scala
@@ -27,5 +27,4 @@ object NewThreadScheduler {
   }
 }
 
-class NewThreadScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
-  extends Scheduler {}
+class NewThreadScheduler private[scala] (val asJavaScheduler: rx.Scheduler) extends Scheduler {}
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala
deleted file mode 100644
index 8f64bb4f84..0000000000
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ScheduledExecutorServiceScheduler.scala
+++ /dev/null
@@ -1,33 +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.lang.scala.schedulers
-
-import java.util.concurrent.ScheduledExecutorService
-import rx.lang.scala.Scheduler
-
-object ScheduledExecutorServiceScheduler {
-
-  /**
-   * Returns a [[rx.lang.scala.Scheduler]] that queues work on an `java.util.concurrent.ScheduledExecutorService`.
-   */
-  def apply(executor: ScheduledExecutorService): ScheduledExecutorServiceScheduler =  {
-    new ScheduledExecutorServiceScheduler(rx.schedulers.Schedulers.executor(executor))
-  }
-}
-
-class ScheduledExecutorServiceScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
-  extends Scheduler {}
-
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala
index 3d853f87e9..c8ddb76673 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TestScheduler.scala
@@ -17,13 +17,14 @@ package rx.lang.scala.schedulers
 
 import scala.concurrent.duration.Duration
 import rx.lang.scala.Scheduler
+import rx.schedulers
 
 /**
  * Provides constructors for `TestScheduler`.
  */
 object TestScheduler {
   def apply(): TestScheduler = {
-    new TestScheduler(new rx.schedulers.TestScheduler())
+    new TestScheduler(new schedulers.TestScheduler())
   }
 }
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala
deleted file mode 100644
index 38e321bc04..0000000000
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ThreadPoolForComputationScheduler.scala
+++ /dev/null
@@ -1,37 +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.lang.scala.schedulers
-
-import rx.lang.scala.Scheduler
-
-object ThreadPoolForComputationScheduler {
-
-  /**
-   * Returns a [[rx.lang.scala.Scheduler]] intended for computational work.
-   *
-   * The implementation is backed by a `java.util.concurrent.ScheduledExecutorService` thread-pool sized to the number of CPU cores.
-   *
-   * This can be used for event-loops, processing callbacks and other computational work.
-   *
-   * Do not perform IO-bound work on this scheduler. Use [[rx.lang.scala.schedulers.ThreadPoolForIOScheduler]] instead.
-   */
-  def apply(): ThreadPoolForComputationScheduler = {
-    new ThreadPoolForComputationScheduler(rx.schedulers.Schedulers.threadPoolForComputation())
-  }
-}
-
-class ThreadPoolForComputationScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
-  extends Scheduler {}
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TrampolineScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TrampolineScheduler.scala
new file mode 100644
index 0000000000..0ff50c1770
--- /dev/null
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/TrampolineScheduler.scala
@@ -0,0 +1,15 @@
+package rx.lang.scala.schedulers
+
+import rx.lang.scala.Scheduler
+
+object TrampolineScheduler {
+  /**
+   * {@link Scheduler} that queues work on the current thread to be executed after the current work completes.
+   */
+  def apply(): TrampolineScheduler =  {
+    new TrampolineScheduler(rx.schedulers.Schedulers.trampoline())
+  }
+}
+
+class TrampolineScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
+  extends Scheduler {}
diff --git a/settings.gradle b/settings.gradle
index 348fadb319..2122bb8ff6 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -3,7 +3,7 @@ include 'rxjava-core', \
 'language-adaptors:rxjava-groovy', \
 'language-adaptors:rxjava-clojure', \
 'language-adaptors:rxjava-jruby', \
-//'language-adaptors:rxjava-scala', \
+'language-adaptors:rxjava-scala', \
 //'language-adaptors:rxjava-kotlin', \
 'rxjava-contrib:rxjava-swing', \
 'rxjava-contrib:rxjava-android', \

From 8ff7d40704d4bf264e5bac80edae16eb399f9f19 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 21:39:53 +0100
Subject: [PATCH 310/441] CompositeSubscription memory reduction

---
 .../rx/subscriptions/CompositeSubscription.java  | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 483e9ef98e..834e0ea2bc 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -17,7 +17,6 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -34,7 +33,15 @@ public final class CompositeSubscription implements Subscription {
 
     private final AtomicReference state = new AtomicReference();
 
-    private static final State CLEAR_STATE = new State(false, new Subscription[0]);
+    /** Empty initial state. */
+    private static final State CLEAR_STATE;
+    /** Unsubscribed empty state. */
+    private static final State CLEAR_STATE_UNSUBSCRIBED;
+    static {
+        Subscription[] s0 = new Subscription[0];
+        CLEAR_STATE = new State(false, s0);
+        CLEAR_STATE_UNSUBSCRIBED = new State(true, s0);
+    }
 
     private static final class State {
         final boolean isUnsubscribed;
@@ -46,7 +53,7 @@ private static final class State {
         }
 
         State unsubscribe() {
-            return new State(true, subscriptions);
+            return CLEAR_STATE_UNSUBSCRIBED;
         }
 
         State add(Subscription s) {
@@ -66,7 +73,7 @@ State remove(Subscription s) {
         }
 
         State clear() {
-            return new State(isUnsubscribed, new Subscription[0]);
+            return isUnsubscribed ? CLEAR_STATE_UNSUBSCRIBED : CLEAR_STATE;
         }
     }
 
@@ -78,6 +85,7 @@ public CompositeSubscription(final Subscription... subscriptions) {
         state.set(new State(false, subscriptions));
     }
 
+    @Override
     public boolean isUnsubscribed() {
         return state.get().isUnsubscribed;
     }

From f3a7f3de732a2dc0bb91b1ae5e01545de553dbb4 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 23:14:44 +0100
Subject: [PATCH 311/441] CompositeSubscription performance increase

---
 .../subscriptions/CompositeSubscription.java  | 30 +++++++++--
 .../CompositeSubscriptionAddRemovePerf.java   | 50 +++++++++++++++++++
 2 files changed, 75 insertions(+), 5 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 834e0ea2bc..0c492bb861 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -57,19 +57,39 @@ State unsubscribe() {
         }
 
         State add(Subscription s) {
-            Subscription[] newSubscriptions = Arrays.copyOf(subscriptions, subscriptions.length + 1);
-            newSubscriptions[newSubscriptions.length - 1] = s;
+            int idx = subscriptions.length;
+            Subscription[] newSubscriptions = new Subscription[idx + 1];
+            System.arraycopy(subscriptions, 0, newSubscriptions, 0, idx);
+            newSubscriptions[idx] = s;
             return new State(isUnsubscribed, newSubscriptions);
         }
 
         State remove(Subscription s) {
-            ArrayList newSubscriptions = new ArrayList(subscriptions.length);
+            if ((subscriptions.length == 1 && subscriptions[0].equals(s)) || subscriptions.length == 0) {
+                return clear();
+            }
+            Subscription[] newSubscriptions = new Subscription[subscriptions.length - 1];
+            int idx = 0;
             for (Subscription _s : subscriptions) {
                 if (!_s.equals(s)) {
-                    newSubscriptions.add(_s);
+                    // was not in this composite
+                    if (idx == subscriptions.length) {
+                        return this;
+                    }
+                    newSubscriptions[idx] = _s;
+                    idx++;
                 }
             }
-            return new State(isUnsubscribed, newSubscriptions.toArray(new Subscription[newSubscriptions.size()]));
+            if (idx == 0) {
+                return clear();
+            }
+            // subscription appeared more than once
+            if (idx < newSubscriptions.length) {
+                Subscription[] newSub2 = new Subscription[idx];
+                System.arraycopy(newSubscriptions, 0, newSub2, 0, idx);
+                return new State(isUnsubscribed, newSub2);
+            }
+            return new State(isUnsubscribed, newSubscriptions);
         }
 
         State clear() {
diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
new file mode 100644
index 0000000000..e842fbc261
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -0,0 +1,50 @@
+
+package rx.subscriptions;
+
+import rx.perf.AbstractPerformanceTester;
+import rx.util.functions.Action0;
+
+public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
+    public static void main(String[] args) {
+        final CompositeSubscriptionAddRemovePerf spt = new CompositeSubscriptionAddRemovePerf();
+        try {
+            spt.runTest(new Action0() {
+                @Override
+                public void call() {
+                    spt.timeAddAndRemove();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    /**
+     * Test simple add + remove on a composite.
+     * 
+     * With old Composite add/remove:
+     * 
+     * Run: 10 - 14 985 141 ops/sec 
+     * Run: 11 - 15 257 104 ops/sec 
+     * Run: 12 - 14 797 996 ops/sec 
+     * Run: 13 - 14 438 643 ops/sec 
+     * Run: 14 - 14 985 864 ops/sec 
+     * 
+     * With optimized Composite add/remove:
+     * 
+     * Run: 10 - 19 802 782 ops/sec 
+     * Run: 11 - 18 896 021 ops/sec 
+     * Run: 12 - 18 829 296 ops/sec 
+     * Run: 13 - 19 729 876 ops/sec 
+     * Run: 14 - 19 830 678 ops/sec 
+     * 
+     * about 32% increase
+     */
+    void timeAddAndRemove() {
+        CompositeSubscription csub = new CompositeSubscription();
+        BooleanSubscription bs = new BooleanSubscription();
+        for (int i = 0; i < REPETITIONS; i++) {
+            csub.add(bs);
+            csub.remove(bs);
+        }
+    }
+}

From 3c537f8503b8ee0a89becf6b84349353080ca154 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 5 Feb 2014 16:05:27 -0800
Subject: [PATCH 312/441] Fixing apparent encoding issue

Was causing grief with Git and Eclipse. Odd.
---
 .../CompositeSubscriptionAddRemovePerf.java   | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
index e842fbc261..e4f73c7fbe 100644
--- a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
+++ b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -1,4 +1,3 @@
-
 package rx.subscriptions;
 
 import rx.perf.AbstractPerformanceTester;
@@ -18,24 +17,25 @@ public void call() {
             e.printStackTrace();
         }
     }
+
     /**
      * Test simple add + remove on a composite.
      * 
      * With old Composite add/remove:
      * 
-     * Run: 10 - 14 985 141 ops/sec 
-     * Run: 11 - 15 257 104 ops/sec 
-     * Run: 12 - 14 797 996 ops/sec 
-     * Run: 13 - 14 438 643 ops/sec 
-     * Run: 14 - 14 985 864 ops/sec 
+     * Run: 10 - 14,985,141 ops/sec
+     * Run: 11 - 15,257,104 ops/sec
+     * Run: 12 - 14,797,996 ops/sec
+     * Run: 13 - 14,438,643 ops/sec
+     * Run: 14 - 14,985,864 ops/sec
      * 
      * With optimized Composite add/remove:
      * 
-     * Run: 10 - 19 802 782 ops/sec 
-     * Run: 11 - 18 896 021 ops/sec 
-     * Run: 12 - 18 829 296 ops/sec 
-     * Run: 13 - 19 729 876 ops/sec 
-     * Run: 14 - 19 830 678 ops/sec 
+     * Run: 10 - 19,802,782 ops/sec
+     * Run: 11 - 18,896,021 ops/sec
+     * Run: 12 - 18,829,296 ops/sec
+     * Run: 13 - 19,729,876 ops/sec
+     * Run: 14 - 19,830,678 ops/sec
      * 
      * about 32% increase
      */

From fe48c7238e5d29eec8dfb311a55361d645989899 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 5 Feb 2014 16:10:36 -0800
Subject: [PATCH 313/441] Git keeps modifying this file so committing it how it
 wants it.

---
 .../CompositeSubscriptionAddRemovePerf.java   | 100 +++++++++---------
 1 file changed, 50 insertions(+), 50 deletions(-)

diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
index e4f73c7fbe..b582e9edd0 100644
--- a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
+++ b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -1,50 +1,50 @@
-package rx.subscriptions;
-
-import rx.perf.AbstractPerformanceTester;
-import rx.util.functions.Action0;
-
-public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
-    public static void main(String[] args) {
-        final CompositeSubscriptionAddRemovePerf spt = new CompositeSubscriptionAddRemovePerf();
-        try {
-            spt.runTest(new Action0() {
-                @Override
-                public void call() {
-                    spt.timeAddAndRemove();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * Test simple add + remove on a composite.
-     * 
-     * With old Composite add/remove:
-     * 
-     * Run: 10 - 14,985,141 ops/sec
-     * Run: 11 - 15,257,104 ops/sec
-     * Run: 12 - 14,797,996 ops/sec
-     * Run: 13 - 14,438,643 ops/sec
-     * Run: 14 - 14,985,864 ops/sec
-     * 
-     * With optimized Composite add/remove:
-     * 
-     * Run: 10 - 19,802,782 ops/sec
-     * Run: 11 - 18,896,021 ops/sec
-     * Run: 12 - 18,829,296 ops/sec
-     * Run: 13 - 19,729,876 ops/sec
-     * Run: 14 - 19,830,678 ops/sec
-     * 
-     * about 32% increase
-     */
-    void timeAddAndRemove() {
-        CompositeSubscription csub = new CompositeSubscription();
-        BooleanSubscription bs = new BooleanSubscription();
-        for (int i = 0; i < REPETITIONS; i++) {
-            csub.add(bs);
-            csub.remove(bs);
-        }
-    }
-}
+package rx.subscriptions;
+
+import rx.perf.AbstractPerformanceTester;
+import rx.util.functions.Action0;
+
+public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
+    public static void main(String[] args) {
+        final CompositeSubscriptionAddRemovePerf spt = new CompositeSubscriptionAddRemovePerf();
+        try {
+            spt.runTest(new Action0() {
+                @Override
+                public void call() {
+                    spt.timeAddAndRemove();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Test simple add + remove on a composite.
+     * 
+     * With old Composite add/remove:
+     * 
+     * Run: 10 - 14,985,141 ops/sec
+     * Run: 11 - 15,257,104 ops/sec
+     * Run: 12 - 14,797,996 ops/sec
+     * Run: 13 - 14,438,643 ops/sec
+     * Run: 14 - 14,985,864 ops/sec
+     * 
+     * With optimized Composite add/remove:
+     * 
+     * Run: 10 - 19,802,782 ops/sec
+     * Run: 11 - 18,896,021 ops/sec
+     * Run: 12 - 18,829,296 ops/sec
+     * Run: 13 - 19,729,876 ops/sec
+     * Run: 14 - 19,830,678 ops/sec
+     * 
+     * about 32% increase
+     */
+    void timeAddAndRemove() {
+        CompositeSubscription csub = new CompositeSubscription();
+        BooleanSubscription bs = new BooleanSubscription();
+        for (int i = 0; i < REPETITIONS; i++) {
+            csub.add(bs);
+            csub.remove(bs);
+        }
+    }
+}

From b1a771134f56992a5d374572da4ecb437fab78a4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 5 Feb 2014 16:37:53 -0800
Subject: [PATCH 314/441] Update to use Subscriber/Subscriptions.create

Master had changed since the pull request.
---
 .../OperatorCompoundButtonInput.java          | 22 ++++++++++---------
 .../rx/operators/OperatorEditTextInput.java   | 18 ++++++++-------
 .../java/rx/operators/OperatorViewClick.java  | 19 +++++++++-------
 3 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
index ca9cb7e04e..c945bc039a 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
@@ -15,17 +15,19 @@
  */
 package rx.operators;
 
-import android.view.View;
-import android.widget.CompoundButton;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import android.view.View;
+import android.widget.CompoundButton;
+
 public class OperatorCompoundButtonInput implements Observable.OnSubscribe {
     private final boolean emitInitialValue;
     private final CompoundButton button;
@@ -36,7 +38,7 @@ public OperatorCompoundButtonInput(final CompoundButton button, final boolean em
     }
 
     @Override
-    public void call(final Observer observer) {
+    public void call(final Subscriber observer) {
         final CompositeOnCheckedChangeListener composite = CachedListeners.getFromViewOrCreate(button);
 
         final CompoundButton.OnCheckedChangeListener listener = new CompoundButton.OnCheckedChangeListener() {
@@ -46,12 +48,12 @@ public void onCheckedChanged(final CompoundButton button, final boolean checked)
             }
         };
 
-        final Subscription subscription = new Subscription() {
+        final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
-            public void unsubscribe() {
+            public void call() {
                 composite.removeOnCheckedChangeListener(listener);
             }
-        };
+        });
 
         if (emitInitialValue) {
             observer.onNext(button.isChecked());
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
index 30bb377ef8..94e516bf3e 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
@@ -15,12 +15,14 @@
  */
 package rx.operators;
 
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 import android.text.Editable;
 import android.text.TextWatcher;
 import android.widget.EditText;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
 
 public class OperatorEditTextInput implements Observable.OnSubscribe {
     private final EditText input;
@@ -32,20 +34,20 @@ public OperatorEditTextInput(final EditText input, final boolean emitInitialValu
     }
 
     @Override
-    public void call(final Observer observer) {
+    public void call(final Subscriber observer) {
         final TextWatcher watcher = new SimpleTextWatcher() {
             @Override
             public void afterTextChanged(final Editable editable) {
                 observer.onNext(editable.toString());
             }
         };
-
-        final Subscription subscription = new Subscription() {
+        
+        final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
-            public void unsubscribe() {
+            public void call() {
                 input.removeTextChangedListener(watcher);
             }
-        };
+        });
 
         if (emitInitialValue) {
             observer.onNext(input.getEditableText().toString());
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
index a90d6a7b23..32ed2de185 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
@@ -15,15 +15,18 @@
  */
 package rx.operators;
 
-import android.view.View;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import android.view.View;
+
 public final class OperatorViewClick implements Observable.OnSubscribe {
     private final boolean emitInitialValue;
     private final View view;
@@ -34,7 +37,7 @@ public OperatorViewClick(final View view, final boolean emitInitialValue) {
     }
 
     @Override
-    public void call(final Observer observer) {
+    public void call(final Subscriber observer) {
         final CompositeOnClickListener composite = CachedListeners.getFromViewOrCreate(view);
 
         final View.OnClickListener listener = new View.OnClickListener() {
@@ -44,12 +47,12 @@ public void onClick(final View clicked) {
             }
         };
 
-        final Subscription subscription = new Subscription() {
+        final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
-            public void unsubscribe() {
+            public void call() {
                 composite.removeOnClickListener(listener);
             }
-        };
+        });
 
         if (emitInitialValue) {
             observer.onNext(view);

From 89bb9dbdf7e73c8238dc4a92c8281e8ca3a5ec53 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Thu, 6 Feb 2014 15:13:59 +0800
Subject: [PATCH 315/441] Reimplement 'subscribeOn' using 'lift'

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../rx/operators/OperationSubscribeOn.java    |  97 ----------
 .../rx/operators/OperatorSubscribeOn.java     | 105 +++++++++++
 .../operators/OperationSubscribeOnTest.java   |  54 ------
 .../rx/operators/OperatorSubscribeOnTest.java | 173 ++++++++++++++++++
 5 files changed, 280 insertions(+), 153 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 50fdfdc338..393b7e5d86 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -80,7 +80,6 @@
 import rx.operators.OperationSkipLast;
 import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSkipWhile;
-import rx.operators.OperationSubscribeOn;
 import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationSynchronize;
@@ -97,6 +96,7 @@
 import rx.operators.OperationToObservableFuture;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
+import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorZip;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorFromIterable;
@@ -6967,7 +6967,7 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
      * @see RxJava Wiki: subscribeOn()
      */
     public final Observable subscribeOn(Scheduler scheduler) {
-        return create(OperationSubscribeOn.subscribeOn(this, scheduler));
+        return from(this).lift(new OperatorSubscribeOn(scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
deleted file mode 100644
index 586d9c4287..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * Copyright 2014 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 java.util.concurrent.atomic.AtomicReference;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-
-/**
- * Asynchronously subscribes and unsubscribes Observers on the specified Scheduler.
- * 
    
- * 
- */
-public class OperationSubscribeOn {
-
-    public static  OnSubscribeFunc subscribeOn(Observable source, Scheduler scheduler) {
-        return new SubscribeOn(source, scheduler);
-    }
-
-    private static class SubscribeOn implements OnSubscribeFunc {
-        private final Observable source;
-        private final Scheduler scheduler;
-
-        public SubscribeOn(Observable source, Scheduler scheduler) {
-            this.source = source;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            final CompositeSubscription s = new CompositeSubscription();
-            scheduler.schedule(new Action1() {
-
-                @Override
-                public void call(final Inner inner) {
-                    s.add(new ScheduledSubscription(source.subscribe(observer), inner));
-                }
-
-            });
-            // only include the ScheduledSubscription
-            // but not the actual Subscription from the Scheduler as we need to schedule the unsubscribe action
-            // and therefore can't unsubscribe the scheduler until after the unsubscribe happens
-            return s;
-        }
-    }
-
-    private static class ScheduledSubscription implements Subscription {
-        private final Subscription underlying;
-        private volatile boolean unsubscribed = false;
-        private final Scheduler.Inner scheduler;
-
-        private ScheduledSubscription(Subscription underlying, Inner scheduler) {
-            this.underlying = underlying;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public void unsubscribe() {
-            unsubscribed = true;
-            scheduler.schedule(new Action1() {
-                @Override
-                public void call(Inner inner) {
-                    underlying.unsubscribe();
-                    // tear down this subscription as well now that we're done
-//                    inner.unsubscribe();
-                }
-            });
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return unsubscribed;
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
new file mode 100644
index 0000000000..44a48af955
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -0,0 +1,105 @@
+/**
+ * Copyright 2014 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 rx.Observable;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Asynchronously subscribes and unsubscribes Observers on the specified Scheduler.
+ * 
    
+ * 
+ */
+public class OperatorSubscribeOn implements Operator> {
+
+    private final Scheduler scheduler;
+
+    public OperatorSubscribeOn(Scheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber> call(
+            final Subscriber subscriber) {
+        return new Subscriber>() {
+
+            @Override
+            public void onCompleted() {
+                // ignore
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onNext(final Observable o) {
+                scheduler.schedule(new Action1() {
+
+                    @Override
+                    public void call(final Inner inner) {
+                        if (!inner.isUnsubscribed()) {
+                            final CompositeSubscription cs = new CompositeSubscription();
+                            subscriber.add(Subscriptions.create(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    scheduler.schedule(new Action1() {
+
+                                        @Override
+                                        public void call(final Inner inner) {
+                                            cs.unsubscribe();
+                                            inner.unsubscribe();
+                                        }
+
+                                    });
+                                }
+
+                            }));
+                            cs.add(subscriber);
+                            o.subscribe(new Subscriber(cs) {
+
+                                @Override
+                                public void onCompleted() {
+                                    subscriber.onCompleted();
+                                }
+
+                                @Override
+                                public void onError(Throwable e) {
+                                    subscriber.onError(e);
+                                }
+
+                                @Override
+                                public void onNext(T t) {
+                                    subscriber.onNext(t);
+                                }
+                            });
+                        }
+                    }
+
+                });
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
deleted file mode 100644
index 380c78eb02..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationSubscribeOnTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Copyright 2014 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 static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationSubscribeOn.*;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscription;
-import rx.schedulers.Schedulers;
-import rx.test.OperatorTester;
-import rx.util.functions.Action1;
-
-public class OperationSubscribeOnTest {
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void testSubscribeOn() {
-        Observable w = Observable.from(1, 2, 3);
-
-        Scheduler scheduler = spy(OperatorTester.forwardingScheduler(Schedulers.immediate()));
-
-        Observer observer = mock(Observer.class);
-        Subscription subscription = Observable.create(subscribeOn(w, scheduler)).subscribe(observer);
-
-        verify(scheduler, times(1)).schedule(any(Action1.class));
-        subscription.unsubscribe();
-        verify(scheduler, times(1)).schedule(any(Action1.class));
-        verifyNoMoreInteractions(scheduler);
-
-        verify(observer, times(1)).onNext(1);
-        verify(observer, times(1)).onNext(2);
-        verify(observer, times(1)).onNext(3);
-        verify(observer, times(1)).onCompleted();
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
new file mode 100644
index 0000000000..28395d5845
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -0,0 +1,173 @@
+/**
+ * Copyright 2014 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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observers.TestObserver;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.Subscriptions;
+import rx.test.OperatorTester;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+public class OperatorSubscribeOnTest {
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testSubscribeOn() {
+        Observable w = Observable.from(Arrays.asList(1, 2, 3));
+
+        Scheduler scheduler = spy(OperatorTester.forwardingScheduler(Schedulers
+                .immediate()));
+
+        TestObserver observer = new TestObserver();
+        w.subscribeOn(scheduler).subscribe(observer);
+
+        InOrder inOrder = inOrder(scheduler);
+        // The first one is for "subscribe", the second one is for
+        // "unsubscribe".
+        inOrder.verify(scheduler, times(2)).schedule(isA(Action1.class));
+        inOrder.verifyNoMoreInteractions();
+
+        observer.assertReceivedOnNext(Arrays.asList(1, 2, 3));
+        observer.assertTerminalEvent();
+    }
+
+    private class ThreadSubscription implements Subscription {
+        private volatile Thread thread;
+
+        private final CountDownLatch latch = new CountDownLatch(1);
+
+        private final Subscription s = Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                thread = Thread.currentThread();
+                latch.countDown();
+            }
+
+        });
+
+        @Override
+        public void unsubscribe() {
+            s.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return s.isUnsubscribed();
+        }
+
+        public Thread getThread() throws InterruptedException {
+            latch.await();
+            return thread;
+        }
+    }
+
+    @Test
+    public void testSubscribeOnAndVerifySubscribeAndUnsubscribeThreads()
+            throws InterruptedException {
+        final ThreadSubscription subscription = new ThreadSubscription();
+        final AtomicReference subscribeThread = new AtomicReference();
+        Observable w = Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber t1) {
+                subscribeThread.set(Thread.currentThread());
+                t1.add(subscription);
+                t1.onNext(1);
+                t1.onNext(2);
+                t1.onCompleted();
+            }
+        });
+
+        TestObserver observer = new TestObserver();
+        w.subscribeOn(Schedulers.computation()).subscribe(observer);
+
+        Thread unsubscribeThread = subscription.getThread();
+
+        assertNotNull(unsubscribeThread);
+        assertNotSame(Thread.currentThread(), unsubscribeThread);
+
+        assertNotNull(subscribeThread);
+        assertNotSame(Thread.currentThread(), subscribeThread);
+
+        observer.assertReceivedOnNext(Arrays.asList(1, 2));
+        observer.assertTerminalEvent();
+    }
+
+    @Test
+    public void testIssue813() throws InterruptedException {
+        // https://github.com/Netflix/RxJava/issues/813
+        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch doneLatch = new CountDownLatch(1);
+
+        TestObserver observer = new TestObserver();
+        final ThreadSubscription s = new ThreadSubscription();
+
+        final Subscription subscription = Observable
+                .create(new Observable.OnSubscribe() {
+                    @Override
+                    public void call(
+                            final Subscriber subscriber) {
+                        subscriber.add(s);
+                        try {
+                            latch.await();
+                            // Already called "unsubscribe", "isUnsubscribed"
+                            // shouble be true
+                            if (!subscriber.isUnsubscribed()) {
+                                throw new IllegalStateException(
+                                        "subscriber.isUnsubscribed should be true");
+                            }
+                            subscriber.onCompleted();
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                        } catch (Throwable e) {
+                            subscriber.onError(e);
+                        } finally {
+                            doneLatch.countDown();
+                        }
+                    }
+                }).subscribeOn(Schedulers.computation()).subscribe(observer);
+
+        subscription.unsubscribe();
+        // As unsubscribe is called in other thread, we need to wait for it.
+        s.getThread();
+        latch.countDown();
+        doneLatch.await();
+        assertEquals(0, observer.getOnErrorEvents().size());
+        assertEquals(1, observer.getOnCompletedEvents().size());
+    }
+}

From 8915b8bb5ae9219809368c3ef66406f075327fb6 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Thu, 6 Feb 2014 16:49:10 +0800
Subject: [PATCH 316/441] Remove 'inner.unsubscribe'

---
 rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 44a48af955..674db1d554 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -69,7 +69,6 @@ public void call() {
                                         @Override
                                         public void call(final Inner inner) {
                                             cs.unsubscribe();
-                                            inner.unsubscribe();
                                         }
 
                                     });

From 3c244fbc0c3782e318f36fbfe0bec91c0fcf0fe1 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Thu, 6 Feb 2014 14:19:35 +0100
Subject: [PATCH 317/441] Set setDaemon on NewThreadScheduler

---
 .../src/main/java/rx/schedulers/NewThreadScheduler.java       | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 157ed660e8..00639b93c0 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -40,7 +40,9 @@ public class NewThreadScheduler extends Scheduler {
 
         @Override
         public Thread newThread(Runnable r) {
-            return new Thread(r, "RxNewThreadScheduler-" + count.incrementAndGet());
+            Thread t = new Thread(r, "RxNewThreadScheduler-" + count.incrementAndGet());
+            t.setDaemon(true);
+            return t;
         }
     };
 

From 90f814fa7292aca9044c72da5371c0805749dd11 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Thu, 6 Feb 2014 21:46:12 +0800
Subject: [PATCH 318/441] Using inner and fix unit tests

---
 .../rx/operators/OperatorSubscribeOn.java     | 71 +++++++++----------
 .../rx/operators/OperatorSubscribeOnTest.java | 38 ++--------
 2 files changed, 40 insertions(+), 69 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 674db1d554..94543d67cd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -58,44 +58,41 @@ public void onNext(final Observable o) {
 
                     @Override
                     public void call(final Inner inner) {
-                        if (!inner.isUnsubscribed()) {
-                            final CompositeSubscription cs = new CompositeSubscription();
-                            subscriber.add(Subscriptions.create(new Action0() {
-
-                                @Override
-                                public void call() {
-                                    scheduler.schedule(new Action1() {
-
-                                        @Override
-                                        public void call(final Inner inner) {
-                                            cs.unsubscribe();
-                                        }
-
-                                    });
-                                }
-
-                            }));
-                            cs.add(subscriber);
-                            o.subscribe(new Subscriber(cs) {
-
-                                @Override
-                                public void onCompleted() {
-                                    subscriber.onCompleted();
-                                }
-
-                                @Override
-                                public void onError(Throwable e) {
-                                    subscriber.onError(e);
-                                }
-
-                                @Override
-                                public void onNext(T t) {
-                                    subscriber.onNext(t);
-                                }
-                            });
-                        }
+                        final CompositeSubscription cs = new CompositeSubscription();
+                        subscriber.add(Subscriptions.create(new Action0() {
+
+                            @Override
+                            public void call() {
+                                inner.schedule(new Action1() {
+
+                                    @Override
+                                    public void call(final Inner inner) {
+                                        cs.unsubscribe();
+                                    }
+
+                                });
+                            }
+
+                        }));
+                        cs.add(subscriber);
+                        o.subscribe(new Subscriber(cs) {
+
+                            @Override
+                            public void onCompleted() {
+                                subscriber.onCompleted();
+                            }
+
+                            @Override
+                            public void onError(Throwable e) {
+                                subscriber.onError(e);
+                            }
+
+                            @Override
+                            public void onNext(T t) {
+                                subscriber.onNext(t);
+                            }
+                        });
                     }
-
                 });
             }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 28395d5845..c6e01bc71d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -18,53 +18,25 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
-import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.observers.TestObserver;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.test.OperatorTester;
 import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 public class OperatorSubscribeOnTest {
 
-    @Test
-    @SuppressWarnings("unchecked")
-    public void testSubscribeOn() {
-        Observable w = Observable.from(Arrays.asList(1, 2, 3));
-
-        Scheduler scheduler = spy(OperatorTester.forwardingScheduler(Schedulers
-                .immediate()));
-
-        TestObserver observer = new TestObserver();
-        w.subscribeOn(scheduler).subscribe(observer);
-
-        InOrder inOrder = inOrder(scheduler);
-        // The first one is for "subscribe", the second one is for
-        // "unsubscribe".
-        inOrder.verify(scheduler, times(2)).schedule(isA(Action1.class));
-        inOrder.verifyNoMoreInteractions();
-
-        observer.assertReceivedOnNext(Arrays.asList(1, 2, 3));
-        observer.assertTerminalEvent();
-    }
-
     private class ThreadSubscription implements Subscription {
         private volatile Thread thread;
 
@@ -114,15 +86,17 @@ public void call(Subscriber t1) {
         });
 
         TestObserver observer = new TestObserver();
-        w.subscribeOn(Schedulers.computation()).subscribe(observer);
+        w.subscribeOn(Schedulers.newThread()).subscribe(observer);
 
         Thread unsubscribeThread = subscription.getThread();
 
         assertNotNull(unsubscribeThread);
         assertNotSame(Thread.currentThread(), unsubscribeThread);
 
-        assertNotNull(subscribeThread);
-        assertNotSame(Thread.currentThread(), subscribeThread);
+        assertNotNull(subscribeThread.get());
+        assertNotSame(Thread.currentThread(), subscribeThread.get());
+        // True for Schedulers.newThread()
+        assertTrue(unsubscribeThread == subscribeThread.get());
 
         observer.assertReceivedOnNext(Arrays.asList(1, 2));
         observer.assertTerminalEvent();

From 95ce9aaae00621ce0bc45d89ae89ad6bf867c773 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 11:43:46 -0800
Subject: [PATCH 319/441] Return wrapped Subscription

- make sure the SafeSubscriber is included in what is returned
- then return as Subscription not Subscriber so it can't be cast back to a Subscriber
---
 rxjava-core/src/main/java/rx/Observable.java | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 50fdfdc338..4349750baa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6900,9 +6900,20 @@ public final Subscription subscribe(Subscriber observer) {
             if (isInternalImplementation(observer)) {
                 onSubscribeFunction.call(observer);
             } else {
-                onSubscribeFunction.call(new SafeSubscriber(observer));
+                // assign to `observer` so we return the protected version
+                observer = new SafeSubscriber(observer);
+                onSubscribeFunction.call(observer);
             }
-            return hook.onSubscribeReturn(this, observer);
+            final Subscription returnSubscription = hook.onSubscribeReturn(this, observer);
+            // we return it inside a Subscription so it can't be cast back to Subscriber
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    returnSubscription.unsubscribe();
+                }
+
+            });
         } catch (OnErrorNotImplementedException e) {
             // special handling when onError is not implemented ... we just rethrow
             throw e;

From 65c4a85c1de5d1a68a251788dbb7793b77fbc282 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 5 Feb 2014 16:54:21 -0800
Subject: [PATCH 320/441] Test Repeat with SubscribeOn

---
 .../rx/operators/OperationRepeatTest.java     | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java
index 0153c24cf1..3f06806302 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java
@@ -22,11 +22,14 @@
 import org.junit.Test;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
+import rx.util.functions.Func1;
 
 public class OperationRepeatTest {
 
@@ -59,4 +62,39 @@ public void testNoStackOverFlow() {
         Observable.from(1).repeat(Schedulers.newThread()).take(100000).toBlockingObservable().last();
     }
 
+    @Test
+    public void testRepeatTakeWithSubscribeOn() throws InterruptedException {
+
+        final AtomicInteger counter = new AtomicInteger();
+        Observable oi = Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                System.out.println("invoked!");
+                counter.incrementAndGet();
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onCompleted();
+            }
+        }).subscribeOn(Schedulers.newThread());
+
+        Object[] ys = oi.repeat(Schedulers.newThread()).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                System.out.println("t1: " + t1);
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                return t1;
+            }
+
+        }).take(4).toList().toBlockingObservable().last().toArray();
+
+        assertEquals(2, counter.get());
+        assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
+    }
+
 }

From 85debff560f2abecbc6088994371510bbfaf820b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 11:59:18 -0800
Subject: [PATCH 321/441] OperatorRepeat

---
 rxjava-core/src/main/java/rx/Observable.java  | 17 +++-
 .../java/rx/operators/OperationRepeat.java    | 80 -----------------
 .../java/rx/operators/OperatorRepeat.java     | 87 +++++++++++++++++++
 ...epeatTest.java => OperatorRepeatTest.java} |  2 +-
 4 files changed, 101 insertions(+), 85 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationRepeat.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
 rename rxjava-core/src/test/java/rx/operators/{OperationRepeatTest.java => OperatorRepeatTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4349750baa..bda44b7eeb 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -69,7 +69,7 @@
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
-import rx.operators.OperationRepeat;
+import rx.operators.OperatorRepeat;
 import rx.operators.OperationReplay;
 import rx.operators.OperationRetry;
 import rx.operators.OperationSample;
@@ -1616,7 +1616,7 @@ public final static Observable interval(long interval, TimeUnit unit, Sche
     public final static  Observable just(T value) {
         return from(Arrays.asList(value));
     }
-
+    
     /**
      * Returns an Observable that emits a single item and then completes, on a specified scheduler.
      * 
    
@@ -2355,6 +2355,15 @@ public final static > Observable min(Observab
         return OperationMinMax.min(source);
     }
 
+    /**
+     * Convert the current Observable into an Observable>.
+     * 
+     * @return
+     */
+    private final Observable> nest() {
+        return from(this);
+    }
+    
     /**
      * Returns an Observable that never sends any items or notifications to an {@link Observer}.
      * 
    
@@ -5518,7 +5527,7 @@ public final  Observable reduce(R initialValue, Func2 acc
      * @see MSDN: Observable.Repeat
      */
     public final Observable repeat() {
-        return this.repeat(Schedulers.currentThread());
+        return nest().lift(new OperatorRepeat());
     }
 
     /**
@@ -5535,7 +5544,7 @@ public final Observable repeat() {
      * @see MSDN: Observable.Repeat
      */
     public final Observable repeat(Scheduler scheduler) {
-        return create(OperationRepeat.repeat(this, scheduler));
+        return nest().lift(new OperatorRepeat(scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java b/rxjava-core/src/main/java/rx/operators/OperationRepeat.java
deleted file mode 100644
index c84cc781f2..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationRepeat.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * Copyright 2014 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 rx.Observable;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.MultipleAssignmentSubscription;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-
-public class OperationRepeat implements Observable.OnSubscribeFunc {
-
-    private final Observable source;
-    private final Scheduler scheduler;
-
-    public static  Observable.OnSubscribeFunc repeat(Observable source, Scheduler scheduler) {
-        return new OperationRepeat(source, scheduler);
-    }
-
-    private OperationRepeat(Observable source, Scheduler scheduler) {
-        this.source = source;
-        this.scheduler = scheduler;
-    }
-
-    @Override
-    public Subscription onSubscribe(final Observer observer) {
-        final CompositeSubscription compositeSubscription = new CompositeSubscription();
-        final MultipleAssignmentSubscription innerSubscription = new MultipleAssignmentSubscription();
-        compositeSubscription.add(innerSubscription);
-        compositeSubscription.add(scheduler.schedule(new Action1() {
-
-            @Override
-            public void call(Inner inner) {
-                inner.schedule(new Action1() {
-                    @Override
-                    public void call(final Inner inner) {
-                        final Action1 _self = this;
-                        innerSubscription.set(source.subscribe(new Observer() {
-
-                            @Override
-                            public void onCompleted() {
-                                inner.schedule(_self);
-                            }
-
-                            @Override
-                            public void onError(Throwable error) {
-                                observer.onError(error);
-                            }
-
-                            @Override
-                            public void onNext(T value) {
-                                observer.onNext(value);
-                            }
-                        }));
-                    }
-                });
-            }
-
-        }));
-        return compositeSubscription;
-    }
-}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
new file mode 100644
index 0000000000..29a0b692e3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -0,0 +1,87 @@
+/**
+ * Copyright 2014 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 rx.Observable;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.schedulers.Schedulers;
+import rx.util.functions.Action1;
+
+public class OperatorRepeat implements Operator> {
+
+    private final Scheduler scheduler;
+
+    public OperatorRepeat(Scheduler scheduler) {
+        this.scheduler = scheduler;
+
+    }
+
+    public OperatorRepeat() {
+        this(Schedulers.trampoline());
+    }
+
+    @Override
+    public Subscriber> call(final Subscriber child) {
+        return new Subscriber>(child) {
+
+            @Override
+            public void onCompleted() {
+                // ignore as we will keep repeating
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onNext(final Observable t) {
+                scheduler.schedule(new Action1() {
+
+                    final Action1 self = this;
+
+                    @Override
+                    public void call(final Inner inner) {
+
+                        t.subscribe(new Subscriber(child) {
+
+                            @Override
+                            public void onCompleted() {
+                                inner.schedule(self);
+                            }
+
+                            @Override
+                            public void onError(Throwable e) {
+                                child.onError(e);
+                            }
+
+                            @Override
+                            public void onNext(T t) {
+                                child.onNext(t);
+                            }
+
+                        });
+                    }
+
+                });
+            }
+
+        };
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index 3f06806302..31d0fe02cd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -31,7 +31,7 @@
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Func1;
 
-public class OperationRepeatTest {
+public class OperatorRepeatTest {
 
     @Test
     public void testRepetition() {

From c330e6d732422403d1ebe0e1b294710cb7540cc5 Mon Sep 17 00:00:00 2001
From: headinthebox 
Date: Thu, 6 Feb 2014 21:13:35 +0100
Subject: [PATCH 322/441] Fixed cut & paster error in io scheduler

---
 .../rx/lang/scala/schedulers/ComputationScheduler.scala    | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
index 8c2eeda134..608d390c64 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ComputationScheduler.scala
@@ -13,13 +13,10 @@ object ComputationScheduler {
    *
    * @return { @link Scheduler} for computation-bound work.
    */
-  def apply(): IOScheduler = {
-    new IOScheduler(rx.schedulers.Schedulers.computation())
+  def apply(): ComputationScheduler = {
+    new ComputationScheduler(rx.schedulers.Schedulers.computation())
   }
 }
 
-/**
- * Created by netflix on 2/5/14.
- */
 class ComputationScheduler private[scala] (val asJavaScheduler: rx.Scheduler)
   extends Scheduler {}
\ No newline at end of file

From cb664ff589e3eac5a9fafe5a0c1b137d901c2bb3 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 10:04:29 +0100
Subject: [PATCH 323/441] Repeat with Count

- merging changes from https://github.com/Netflix/RxJava/pull/807
---
 rxjava-core/src/main/java/rx/Observable.java  | 33 +++++++++++
 .../java/rx/operators/OperatorRepeat.java     | 28 +++++++--
 .../java/rx/operators/OperatorRepeatTest.java | 58 +++++++++++++++++--
 3 files changed, 110 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index bda44b7eeb..c5e214d94c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5547,6 +5547,39 @@ public final Observable repeat(Scheduler scheduler) {
         return nest().lift(new OperatorRepeat(scheduler));
     }
 
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source
+     * Observable at most count times.
+     * 
+     * @param count
+     *            the number of times the source Observable items are repeated,
+     *            a count of 0 will yield an empty sequence.
+     * @return an Observable that repeats the sequence of items emitted by the source
+     *         Observable at most count times.
+     */
+    public final Observable repeat(long count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count >= 0 expected");
+        }
+        return nest().lift(new OperatorRepeat(count));
+    }
+
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source
+     * Observable at most count times on a particular scheduler.
+     * 
+     * @param count
+     *            the number of times the source Observable items are repeated,
+     *            a count of 0 will yield an empty sequence.
+     * @param scheduler
+     *            the scheduler to emit the items on
+     * @return an Observable that repeats the sequence of items emitted by the source
+     *         Observable at most count times on a particular scheduler.
+     */
+    public final Observable repeat(long count, Scheduler scheduler) {
+        return nest().lift(new OperatorRepeat(count, scheduler));
+    }
+
     /**
      * 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}.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 29a0b692e3..9f9768cf33 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -20,26 +20,42 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
 import rx.util.functions.Action1;
 
 public class OperatorRepeat implements Operator> {
 
     private final Scheduler scheduler;
+    private final long count;
 
-    public OperatorRepeat(Scheduler scheduler) {
+    public OperatorRepeat(long count, Scheduler scheduler) {
         this.scheduler = scheduler;
+        this.count = count;
+    }
 
+    public OperatorRepeat(Scheduler scheduler) {
+        this(-1, scheduler);
+    }
+
+    public OperatorRepeat(long count) {
+        this(count, Schedulers.trampoline());
     }
 
     public OperatorRepeat() {
-        this(Schedulers.trampoline());
+        this(-1, Schedulers.trampoline());
     }
 
     @Override
     public Subscriber> call(final Subscriber child) {
+        if (count == 0) {
+            child.onCompleted();
+            return Subscribers.empty();
+        }
         return new Subscriber>(child) {
 
+            int executionCount = 0;
+
             @Override
             public void onCompleted() {
                 // ignore as we will keep repeating
@@ -58,12 +74,16 @@ public void onNext(final Observable t) {
 
                     @Override
                     public void call(final Inner inner) {
-
+                        executionCount++;
                         t.subscribe(new Subscriber(child) {
 
                             @Override
                             public void onCompleted() {
-                                inner.schedule(self);
+                                if (count == -1 || executionCount < count) {
+                                    inner.schedule(self);
+                                } else {
+                                    child.onCompleted();
+                                }
                             }
 
                             @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index 31d0fe02cd..ce03525167 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -16,6 +16,8 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -33,7 +35,7 @@
 
 public class OperatorRepeatTest {
 
-    @Test
+    @Test(timeout = 2000)
     public void testRepetition() {
         int NUM = 10;
         final AtomicInteger count = new AtomicInteger();
@@ -50,14 +52,14 @@ public Subscription onSubscribe(Observer o) {
         assertEquals(NUM, value);
     }
 
-    @Test
+    @Test(timeout = 2000)
     public void testRepeatTake() {
         Observable xs = Observable.from(1, 2);
         Object[] ys = xs.repeat(Schedulers.newThread()).take(4).toList().toBlockingObservable().last().toArray();
         assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
     }
 
-    @Test
+    @Test(timeout = 20000)
     public void testNoStackOverFlow() {
         Observable.from(1).repeat(Schedulers.newThread()).take(100000).toBlockingObservable().last();
     }
@@ -70,7 +72,6 @@ public void testRepeatTakeWithSubscribeOn() throws InterruptedException {
 
             @Override
             public void call(Subscriber sub) {
-                System.out.println("invoked!");
                 counter.incrementAndGet();
                 sub.onNext(1);
                 sub.onNext(2);
@@ -82,7 +83,6 @@ public void call(Subscriber sub) {
 
             @Override
             public Integer call(Integer t1) {
-                System.out.println("t1: " + t1);
                 try {
                     Thread.sleep(50);
                 } catch (InterruptedException e) {
@@ -97,4 +97,52 @@ public Integer call(Integer t1) {
         assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
     }
 
+    @Test(timeout = 2000)
+    public void testRepeatAndTake() {
+        @SuppressWarnings("unchecked")
+                Observer o = mock(Observer.class);
+        
+        Observable.from(1).repeat().take(10).subscribe(o);
+        
+        verify(o, times(10)).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test(timeout = 2000)
+    public void testRepeatLimited() {
+        @SuppressWarnings("unchecked")
+                Observer o = mock(Observer.class);
+        
+        Observable.from(1).repeat(10).subscribe(o);
+        
+        verify(o, times(10)).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test(timeout = 2000)
+    public void testRepeatError() {
+        @SuppressWarnings("unchecked")
+                Observer o = mock(Observer.class);
+        
+        Observable.error(new CustomException()).repeat(10).subscribe(o);
+        
+        verify(o).onError(any(CustomException.class));
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        
+    }
+    @Test(timeout = 2000)
+    public void testRepeatZero() {
+        @SuppressWarnings("unchecked")
+                Observer o = mock(Observer.class);
+        
+        Observable.from(1).repeat(0).subscribe(o);
+        
+        verify(o).onCompleted();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    private static class CustomException extends RuntimeException {
+    }
 }

From fae7a9b3283a3e895f7bf1ca8d999a67b7c14d59 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 12:20:25 -0800
Subject: [PATCH 324/441] Subscribers/Observers.empty()

---
 .../src/main/java/rx/observers/Observers.java | 37 +++++++-------
 .../main/java/rx/observers/Subscribers.java   | 48 +++++++++----------
 .../main/java/rx/observers/TestObserver.java  |  4 +-
 .../java/rx/observers/TestSubscriber.java     |  5 +-
 .../rx/operators/OperatorZipIterable.java     |  2 +-
 5 files changed, 46 insertions(+), 50 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/Observers.java b/rxjava-core/src/main/java/rx/observers/Observers.java
index 9a7d1a816f..860e3c0a10 100644
--- a/rxjava-core/src/main/java/rx/observers/Observers.java
+++ b/rxjava-core/src/main/java/rx/observers/Observers.java
@@ -1,34 +1,35 @@
 package rx.observers;
 
 import rx.Observer;
+import rx.Subscriber;
 import rx.util.OnErrorNotImplementedException;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 public class Observers {
 
-    /**
-     * Create an empty Observer that ignores all events.
-     */
-    public static final  Observer create() {
-        return new Observer() {
+    private static final Observer EMPTY = new Observer() {
 
-            @Override
-            public final void onCompleted() {
-                // do nothing
-            }
+        @Override
+        public final void onCompleted() {
+            // do nothing
+        }
 
-            @Override
-            public final void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
-            }
+        @Override
+        public final void onError(Throwable e) {
+            throw new OnErrorNotImplementedException(e);
+        }
 
-            @Override
-            public final void onNext(T args) {
-                // do nothing
-            }
+        @Override
+        public final void onNext(Object args) {
+            // do nothing
+        }
 
-        };
+    };
+
+    @SuppressWarnings("unchecked")
+    public static  Observer empty() {
+        return (Observer) EMPTY;
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
index 4cf5e48d14..156656851f 100644
--- a/rxjava-core/src/main/java/rx/observers/Subscribers.java
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.java
@@ -8,6 +8,30 @@
 
 public class Subscribers {
 
+    private static final Subscriber EMPTY = new Subscriber() {
+
+        @Override
+        public final void onCompleted() {
+            // do nothing
+        }
+
+        @Override
+        public final void onError(Throwable e) {
+            throw new OnErrorNotImplementedException(e);
+        }
+
+        @Override
+        public final void onNext(Object args) {
+            // do nothing
+        }
+
+    };
+
+    @SuppressWarnings("unchecked")
+    public static  Subscriber empty() {
+        return (Subscriber) EMPTY;
+    }
+
     public static  Subscriber from(final Observer o) {
         return new Subscriber() {
 
@@ -29,30 +53,6 @@ public void onNext(T t) {
         };
     }
 
-    /**
-     * Create an empty Subscriber that ignores all events.
-     */
-    public static final  Subscriber create() {
-        return new Subscriber() {
-
-            @Override
-            public final void onCompleted() {
-                // do nothing
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
-            }
-
-            @Override
-            public final void onNext(T args) {
-                // do nothing
-            }
-
-        };
-    }
-
     /**
      * Create an Subscriber that receives `onNext` and ignores `onError` and `onCompleted`.
      */
diff --git a/rxjava-core/src/main/java/rx/observers/TestObserver.java b/rxjava-core/src/main/java/rx/observers/TestObserver.java
index a6198ada5b..2ef3685792 100644
--- a/rxjava-core/src/main/java/rx/observers/TestObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/TestObserver.java
@@ -28,7 +28,6 @@
  */
 public class TestObserver implements Observer {
 
-    private final Observer EMPTY = new EmptyObserver();
 
     private final Observer delegate;
     private final ArrayList onNextEvents = new ArrayList();
@@ -39,9 +38,8 @@ public TestObserver(Observer delegate) {
         this.delegate = delegate;
     }
 
-    @SuppressWarnings("unchecked")
     public TestObserver() {
-        this.delegate = (Observer) EMPTY;
+        this.delegate = Observers.empty();
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index 097c6e8e24..2eb28a767d 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -26,8 +26,6 @@
  */
 public class TestSubscriber extends Subscriber {
 
-    private final Subscriber EMPTY = Subscribers.create();
-
     private final TestObserver testObserver;
 
     public TestSubscriber(Subscriber delegate) {
@@ -38,9 +36,8 @@ public TestSubscriber(Observer delegate) {
         this.testObserver = new TestObserver(delegate);
     }
 
-    @SuppressWarnings("unchecked")
     public TestSubscriber() {
-        this.testObserver = new TestObserver((Subscriber) EMPTY);
+        this.testObserver = new TestObserver(Subscribers.empty());
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
index eac5f80809..0ded7f0d5d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
@@ -37,7 +37,7 @@ public Subscriber call(final Subscriber subscriber) {
         try {
             if (!iterator.hasNext()) {
                 subscriber.onCompleted();
-                return Subscribers.create();
+                return Subscribers.empty();
             }
         } catch (Throwable e) {
             subscriber.onError(e);

From 9f124355811e1913c43f8b2124c987bec1ad9d30 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 6 Feb 2014 13:25:31 -0800
Subject: [PATCH 325/441] adding marble diagrams, see-also links to javadocs of
 new repeat() variants

---
 rxjava-core/src/main/java/rx/Observable.java | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c5e214d94c..8f866acb2b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5550,12 +5550,16 @@ public final Observable repeat(Scheduler scheduler) {
     /**
      * Returns an Observable that repeats the sequence of items emitted by the source
      * Observable at most count times.
+     * 
    
+     * 
      * 
      * @param count
      *            the number of times the source Observable items are repeated,
-     *            a count of 0 will yield an empty sequence.
+     *            a count of 0 will yield an empty sequence
      * @return an Observable that repeats the sequence of items emitted by the source
-     *         Observable at most count times.
+     *         Observable at most {@code count} times
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
      */
     public final Observable repeat(long count) {
         if (count < 0) {
@@ -5567,14 +5571,18 @@ public final Observable repeat(long count) {
     /**
      * Returns an Observable that repeats the sequence of items emitted by the source
      * Observable at most count times on a particular scheduler.
+     * 
    
+     * 
      * 
      * @param count
      *            the number of times the source Observable items are repeated,
      *            a count of 0 will yield an empty sequence.
      * @param scheduler
-     *            the scheduler to emit the items on
+     *            the {@link Scheduler} to emit the items on
      * @return an Observable that repeats the sequence of items emitted by the source
-     *         Observable at most count times on a particular scheduler.
+     *         Observable at most {@code count} times on a particular Scheduler
+     * @see RxJava Wiki: repeat()
+     * @see MSDN: Observable.Repeat
      */
     public final Observable repeat(long count, Scheduler scheduler) {
         return nest().lift(new OperatorRepeat(count, scheduler));

From b6a9c5c932754c4e410e00c654e1e46537cccf74 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 6 Feb 2014 13:31:04 -0800
Subject: [PATCH 326/441] Changing marble diagrams for repeat() variants to
 those that operate on a source Observable rather than a source item

---
 rxjava-core/src/main/java/rx/Observable.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 8f866acb2b..5bba3175b1 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5519,7 +5519,7 @@ public final  Observable reduce(R initialValue, Func2 acc
      * Returns an Observable that repeats the sequence of items emitted by the source Observable
      * indefinitely.
      * 
    
-     * 
+     * 
      * 
      * @return an Observable that emits the items emitted by the source Observable repeatedly and in
      *         sequence
@@ -5534,7 +5534,7 @@ public final Observable repeat() {
      * Returns an Observable that repeats the sequence of items emitted by the source Observable
      * indefinitely, on a particular scheduler.
      * 
    
-     * 
+     * 
      * 
      * @param scheduler
      *            the scheduler to emit the items on
@@ -5551,7 +5551,7 @@ public final Observable repeat(Scheduler scheduler) {
      * Returns an Observable that repeats the sequence of items emitted by the source
      * Observable at most count times.
      * 
    
-     * 
+     * 
      * 
      * @param count
      *            the number of times the source Observable items are repeated,
@@ -5572,7 +5572,7 @@ public final Observable repeat(long count) {
      * Returns an Observable that repeats the sequence of items emitted by the source
      * Observable at most count times on a particular scheduler.
      * 
    
-     * 
+     * 
      * 
      * @param count
      *            the number of times the source Observable items are repeated,

From a2259447b98af43b87bea6c47c6d6ea1a9326faa Mon Sep 17 00:00:00 2001
From: Duncan Irvine 
Date: Fri, 7 Feb 2014 11:03:48 +1100
Subject: [PATCH 327/441] [Issue #831] Fix for OperationJoin race condition

---
 .../main/java/rx/operators/OperationJoin.java | 49 +++++++++++--------
 1 file changed, 29 insertions(+), 20 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index 057aefc45b..6211040b76 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -109,10 +109,12 @@ protected void expire(int id, Subscription resource) {
 
             @Override
             public void onNext(TLeft args) {
-                int id;
+                int id, highRightId;
+
                 synchronized (gate) {
                     id = leftId++;
                     leftMap.put(id, args);
+                    highRightId = rightId;
                 }
                 SerialSubscription md = new SerialSubscription();
                 group.add(md);
@@ -129,16 +131,19 @@ public void onNext(TLeft args) {
                 md.setSubscription(duration.subscribe(new LeftDurationObserver(id, md)));
 
                 synchronized (gate) {
-                    for (TRight r : rightMap.values()) {
-                        R result;
-                        try {
-                            result = resultSelector.call(args, r);
-                        } catch (Throwable t) {
-                            observer.onError(t);
-                            cancel.unsubscribe();
-                            return;
+                    for (Map.Entry entry : rightMap.entrySet()) {
+                        if (entry.getKey() < highRightId) {
+                            TRight r = entry.getValue();
+                            R result;
+                            try {
+                                result = resultSelector.call(args, r);
+                            } catch (Throwable t) {
+                                observer.onError(t);
+                                cancel.unsubscribe();
+                                return;
+                            }
+                            observer.onNext(result);
                         }
-                        observer.onNext(result);
                     }
                 }
             }
@@ -212,10 +217,11 @@ void expire(int id, Subscription resource) {
 
             @Override
             public void onNext(TRight args) {
-                int id = 0;
+                int id = 0, highLeftId;
                 synchronized (gate) {
                     id = rightId++;
                     rightMap.put(id, args);
+                    highLeftId = leftId;
                 }
                 SerialSubscription md = new SerialSubscription();
                 group.add(md);
@@ -232,16 +238,19 @@ public void onNext(TRight args) {
                 md.setSubscription(duration.subscribe(new RightDurationObserver(id, md)));
 
                 synchronized (gate) {
-                    for (TLeft lv : leftMap.values()) {
-                        R result;
-                        try {
-                            result = resultSelector.call(lv, args);
-                        } catch (Throwable t) {
-                            observer.onError(t);
-                            cancel.unsubscribe();
-                            return;
+                    for (Map.Entry entry : leftMap.entrySet()) {
+                        if (entry.getKey() < highLeftId) {
+                            TLeft lv = entry.getValue();
+                            R result;
+                            try {
+                                result = resultSelector.call(lv, args);
+                            } catch (Throwable t) {
+                                observer.onError(t);
+                                cancel.unsubscribe();
+                                return;
+                            }
+                            observer.onNext(result);
                         }
-                        observer.onNext(result);
                     }
                 }
             }

From ff394f7df04031438490b5ea22680acc58453d4f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 19:51:29 -0800
Subject: [PATCH 328/441] Take operator was breaking the unsubscribe chain

Fixes issue https://github.com/Netflix/RxJava/issues/830
---
 .../main/java/rx/operators/OperatorTake.java  | 18 +++++++-----
 .../java/rx/operators/OperatorTakeTest.java   | 28 +++++++++++++++++++
 2 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTake.java b/rxjava-core/src/main/java/rx/operators/OperatorTake.java
index c1463608cc..e58e120386 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTake.java
@@ -38,18 +38,22 @@ public OperatorTake(int limit) {
     }
 
     @Override
-    public Subscriber call(final Subscriber o) {
-        CompositeSubscription parent = new CompositeSubscription();
+    public Subscriber call(final Subscriber child) {
+        final CompositeSubscription parent = new CompositeSubscription();
         if (limit == 0) {
-            o.onCompleted();
+            child.onCompleted();
             parent.unsubscribe();
         }
+
         /*
          * We decouple the parent and child subscription so there can be multiple take() in a chain
          * such as for the groupBy Observer use case where you may take(1) on groups and take(20) on the children.
          * 
          * Thus, we only unsubscribe UPWARDS to the parent and an onComplete DOWNSTREAM.
+         * 
+         * However, if we receive an unsubscribe from the child we still want to propagate it upwards so we register 'parent' with 'child'
          */
+        child.add(parent);
         return new Subscriber(parent) {
 
             int count = 0;
@@ -58,24 +62,24 @@ public Subscriber call(final Subscriber o) {
             @Override
             public void onCompleted() {
                 if (!completed) {
-                    o.onCompleted();
+                    child.onCompleted();
                 }
             }
 
             @Override
             public void onError(Throwable e) {
                 if (!completed) {
-                    o.onError(e);
+                    child.onError(e);
                 }
             }
 
             @Override
             public void onNext(T i) {
                 if (!isUnsubscribed()) {
-                    o.onNext(i);
+                    child.onNext(i);
                     if (++count >= limit) {
                         completed = true;
-                        o.onCompleted();
+                        child.onCompleted();
                         unsubscribe();
                     }
                 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 5331bfa90a..9eb07b20ef 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -21,6 +21,7 @@
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 import org.junit.Test;
@@ -210,6 +211,33 @@ public void call(Long l) {
         assertEquals(10, count.get());
     }
 
+    @Test(timeout = 2000)
+    public void testMultiTake() {
+        final AtomicInteger count = new AtomicInteger();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber s) {
+                for (int i = 0; !s.isUnsubscribed(); i++) {
+                    System.out.println("Emit: " + i);
+                    count.incrementAndGet();
+                    s.onNext(i);
+                }
+            }
+
+        }).take(100).take(1).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(Integer t1) {
+                System.out.println("Receive: " + t1);
+
+            }
+
+        });
+
+        assertEquals(1, count.get());
+    }
+
     private static class TestObservableFunc implements Observable.OnSubscribeFunc {
 
         final Subscription s;

From 53e102d5182de8f182ee440fe98d725e31162125 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 20:06:39 -0800
Subject: [PATCH 329/441] from(this) -> nest()

---
 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 216143c708..542bedbff2 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7028,7 +7028,7 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
      * @see RxJava Wiki: subscribeOn()
      */
     public final Observable subscribeOn(Scheduler scheduler) {
-        return from(this).lift(new OperatorSubscribeOn(scheduler));
+        return nest().lift(new OperatorSubscribeOn(scheduler));
     }
 
     /**

From 9520d6328687bb3ab259097c4b203bfc0ec262df Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 20:07:27 -0800
Subject: [PATCH 330/441] Remove line break

---
 .../src/main/java/rx/operators/OperatorSubscribeOn.java        | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 94543d67cd..7355a538ad 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -38,8 +38,7 @@ public OperatorSubscribeOn(Scheduler scheduler) {
     }
 
     @Override
-    public Subscriber> call(
-            final Subscriber subscriber) {
+    public Subscriber> call(final Subscriber subscriber) {
         return new Subscriber>() {
 
             @Override

From bae0ffa1b9480855dc83d89634d9793cfc08bfcb Mon Sep 17 00:00:00 2001
From: Dave Ray 
Date: Thu, 6 Feb 2014 20:53:24 -0800
Subject: [PATCH 331/441] Updated nrepl task

---
 language-adaptors/rxjava-clojure/build.gradle | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/language-adaptors/rxjava-clojure/build.gradle b/language-adaptors/rxjava-clojure/build.gradle
index 6e59b61305..7332fb350e 100644
--- a/language-adaptors/rxjava-clojure/build.gradle
+++ b/language-adaptors/rxjava-clojure/build.gradle
@@ -50,3 +50,26 @@ jar {
         instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Define a task that runs an nrepl server. The port is given with the nreplPort
+// property:
+//    gradlew nrepl -PnreplPort=9999
+// or put the property in ~/.gradle/gradle.properties
+
+def nreplPortValue = (project.hasProperty('nreplPort') && !project.nreplPort.isEmpty()) ? project.nreplPort : '9999'
+configurations { nrepl }
+dependencies { nrepl 'org.clojure:tools.nrepl:0.2.2' }
+task nrepl(type: JavaExec) {
+    classpath configurations.nrepl,
+              project.sourceSets.main.clojure.srcDirs,
+              project.sourceSets.test.clojure.srcDirs,
+              sourceSets.main.runtimeClasspath,
+              sourceSets.test.runtimeClasspath
+
+    main = "clojure.main"
+    args '--eval', "(ns gradle-nrepl (:require [clojure.tools.nrepl.server :refer (start-server stop-server)]))",
+         '--eval', "(println \"Starting nrepl server on port $nreplPortValue\")",
+         '--eval', "(def server (start-server :port $nreplPortValue))"
+}

From d7df8295a0f1a09e8b41e1d5d09a3b7db15f8621 Mon Sep 17 00:00:00 2001
From: Dave Ray 
Date: Thu, 6 Feb 2014 21:03:51 -0800
Subject: [PATCH 332/441] Make rx/action implement new OnSubscribe interface

---
 language-adaptors/rxjava-clojure/README.md          | 13 +++++++++++++
 .../src/main/clojure/rx/lang/clojure/interop.clj    | 10 +++++++++-
 .../test/clojure/rx/lang/clojure/interop_test.clj   | 11 ++++++++++-
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index bb452b98a3..b2f69b3853 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -46,6 +46,19 @@ The `rx/action` macro is identical to `rx/fn` except that the object returned im
                 (rx/action [] (println "Sequence complete"))))
 ```
 
+## Using Observable/create
+As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnSubscribe` which is basically an alias for `rx.util.functions.Action1` that takes an `rx.Subscriber` as its argument. Thus, you can just use `rx/action` when creating new observables:
+
+```clojure
+; A simple observable that emits 0..9 taking unsubscribe into account
+(Observable/create (rx/action [^rx.Subscriber s]
+                     (loop [i 0]
+                       (when (and (< i 10) (.isUnsubscribed s))
+                         (.onNext s i)
+                         (recur (inc i))))
+                     (.onCompleted s)))
+```
+
 # Gotchas
 Here are a few things to keep in mind when using this interop:
 
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
index 140f5367c5..415aab8bab 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
@@ -19,12 +19,19 @@
        (reify
          ; If they want Func1, give them onSubscribe as well so Observable/create can be
          ; used seemlessly with rx/fn.
+         ; TODO remove this when OnSubscriberFunc is removed
          ~@(if (and (= prefix "rx.util.functions.Func")
                     (some #{1} arities))
              `(rx.Observable$OnSubscribeFunc
                 (~'onSubscribe [~'this observer#]
                   (~f-name observer#))))
 
+         ; OnSubscribe is just an Action1, so add it to the list of implemented interfaces
+         ; so an action cab be used with Observable/create
+         ~@(if (and (= prefix "rx.util.functions.Action")
+                    (some #{1} arities))
+             `(rx.Observable$OnSubscribe))
+
          ~@(mapcat (clojure.core/fn [n]
                      (let [ifc-sym  (symbol (str prefix n))
                            arg-syms (map #(symbol (str "v" %)) (range n))]
@@ -94,7 +101,8 @@
 
 (defn action*
   "Given function f, returns an object that implements rx.util.functions.Action0-3
-  by delegating to the given function.
+  by delegating to the given function. Also implements rx.Observable$OnSubscribe which
+  is just an Action1.
 
   Example:
 
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
index 2eae2329ed..cd6441ea10 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
@@ -70,6 +70,7 @@
   (testing "implements Action0-3"
     (let [calls (atom [])
           a (rx/action* #(swap! calls conj (vec %&)))]
+      (is (instance? rx.Observable$OnSubscribe a))
       (is (instance? rx.util.functions.Action0 a))
       (is (instance? rx.util.functions.Action1 a))
       (is (instance? rx.util.functions.Action2 a))
@@ -114,7 +115,7 @@
 
 (deftest test-basic-usage
 
-  (testing "can create an observable"
+  (testing "can create an observable with old style fn"
     (is (= 99
            (-> (Observable/create (rx/fn [^rx.Observer o]
                                     (.onNext o 99)
@@ -123,6 +124,14 @@
                .toBlockingObservable
                .single))))
 
+  (testing "can create an observable with new-style action"
+    (is (= 99
+           (-> (Observable/create (rx/action [^rx.Subscriber s]
+                                    (when-not (.isUnsubscribed s)
+                                      (.onNext s 99))
+                                    (.onCompleted s)))
+               .toBlockingObservable
+               .single))))
   (testing "can pass rx/fn to map and friends"
     (is (= (+ 1 4 9)
            (-> (Observable/from [1 2 3])

From f74ad55d6c814ba01e52bff8a750938d478bb004 Mon Sep 17 00:00:00 2001
From: Dave Ray 
Date: Thu, 6 Feb 2014 21:58:54 -0800
Subject: [PATCH 333/441] Update Clojure examples to use new Observable/create

---
 .../lang/clojure/examples/http_examples.clj   |  12 +-
 .../rx/lang/clojure/examples/rx_examples.clj  | 118 ++++++++----------
 .../lang/clojure/examples/video_example.clj   |  60 +++++----
 3 files changed, 96 insertions(+), 94 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/http_examples.clj b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/http_examples.clj
index 857df10020..958d527486 100644
--- a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/http_examples.clj
+++ b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/http_examples.clj
@@ -1,12 +1,12 @@
 ;
 ; 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.
@@ -27,14 +27,14 @@
 
    return Observable of HTML"
   (Observable/create
-    (rx/fn [observer]
+    (rx/action [observer]
       (let [f (future
                 (doseq [articleName wikipediaArticleNames]
                   (-> observer (.onNext (http/get (str "http://en.wikipedia.org/wiki/" articleName)))))
                 ; after sending response to onnext we complete the sequence
                 (-> observer .onCompleted))]
         ; a subscription that cancels the future if unsubscribed
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
+        (.add observer (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
 ; To see output
 (comment
@@ -52,7 +52,7 @@
 
    return Observable of HTML"
   (Observable/create
-    (rx/fn [observer]
+    (rx/action [observer]
       (let [f (future
                 (try
                   (doseq [articleName wikipediaArticleNames]
@@ -62,7 +62,7 @@
                 ; after sending response to onNext we complete the sequence
                 (-> observer .onCompleted))]
         ; a subscription that cancels the future if unsubscribed
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
+        (.add observer (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
 ; To see output
 (comment
diff --git a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
index 403a9b4495..af0d7328c0 100644
--- a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
+++ b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/rx_examples.clj
@@ -1,12 +1,12 @@
 ;
 ; 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.
@@ -58,53 +58,37 @@
 ; Custom Observable
 ; --------------------------------------------------
 
-(defn customObservableBlocking []
-  "This example shows a custom Observable that blocks
-   when subscribed to (does not spawn an extra thread).
+(defn customObservable
+  "This example shows a custom Observable. Note the
+  .isUnsubscribed check so that it can be stopped early.
 
   returns Observable"
+  []
   (Observable/create
-    (rx/fn [observer]
-      (doseq [x (range 50)] (-> observer (.onNext (str "value_" x))))
+    (rx/action [^rx.Subscriber s]
+      (loop [x (range 50)]
+        (when (and (not (.isUnsubscribed s)) x)
+          ; TODO
+          (println "HERE " (.isUnsubscribed s) (first x))
+          (-> s (.onNext (str "value_" (first x))))
+          (recur (next x))))
       ; after sending all values we complete the sequence
-      (-> observer .onCompleted)
-      ; return a NoOpSubsription since this blocks and thus
-      ; can't be unsubscribed from
-      (Subscriptions/empty))))
+      (-> s .onCompleted))))
 
 ; To see output
 (comment
-  (.subscribe (customObservableBlocking) (rx/action* println)))
-
-(defn customObservableNonBlocking []
-  "This example shows a custom Observable that does not block
-  when subscribed to as it spawns a separate thread.
-
-  returns Observable"
-  (Observable/create
-    (rx/fn [observer]
-      (let [f (future
-                (doseq [x (range 50)]
-                  (-> observer (.onNext (str "anotherValue_" x))))
-                ; after sending all values we complete the sequence
-                (-> observer .onCompleted))]
-        ; return a subscription that cancels the future
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
-
-; To see output
-(comment
-  (.subscribe (customObservableNonBlocking) (rx/action* println)))
-
+  (.subscribe (customObservable) (rx/action* println)))
 
 ; --------------------------------------------------
 ; Composition - Simple
 ; --------------------------------------------------
 
-(defn simpleComposition []
-  "Asynchronously calls 'customObservableNonBlocking' and defines
+(defn simpleComposition
+  "Calls 'customObservable' and defines
    a chain of operators to apply to the callback sequence."
+  []
   (->
-    (customObservableNonBlocking)
+    (customObservable)
     (.skip 10)
     (.take 5)
     (.map (rx/fn [v] (str v "_transformed")))
@@ -119,66 +103,73 @@
 ; Composition - Multiple async calls combined
 ; --------------------------------------------------
 
-(defn getUser [userId]
+(defn getUser
   "Asynchronously fetch user data
 
   return Observable"
+  [userId]
   (Observable/create
-    (rx/fn [observer]
+    (rx/action [^rx.Subscriber s]
       (let [f (future
                 (try
                   ; simulate fetching user data via network service call with latency
                   (Thread/sleep 60)
-                  (-> observer (.onNext {:user-id userId
-                                         :name "Sam Harris"
-                                         :preferred-language (if (= 0 (rand-int 2)) "en-us" "es-us") }))
-                  (-> observer .onCompleted)
-                  (catch Exception e (-> observer (.onError e))))) ]
+                  (-> s (.onNext {:user-id userId
+                                  :name "Sam Harris"
+                                  :preferred-language (if (= 0 (rand-int 2)) "en-us" "es-us") }))
+                  (-> s .onCompleted)
+                  (catch Exception e
+                    (-> s (.onError e))))) ]
         ; a subscription that cancels the future if unsubscribed
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
+        (.add s (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
-(defn getVideoBookmark [userId, videoId]
+(defn getVideoBookmark
   "Asynchronously fetch bookmark for video
 
   return Observable"
+  [userId, videoId]
   (Observable/create
-    (rx/fn [observer]
+    (rx/action [^rx.Subscriber s]
       (let [f (future
                 (try
                   ; simulate fetching user data via network service call with latency
                   (Thread/sleep 20)
-                  (-> observer (.onNext {:video-id videoId
-                                         ; 50/50 chance of giving back position 0 or 0-2500
-                                         :position (if (= 0 (rand-int 2)) 0 (rand-int 2500))}))
-                  (-> observer .onCompleted)
-                  (catch Exception e (-> observer (.onError e)))))]
+                  (-> s (.onNext {:video-id videoId
+                                  ; 50/50 chance of giving back position 0 or 0-2500
+                                  :position (if (= 0 (rand-int 2)) 0 (rand-int 2500))}))
+                  (-> s .onCompleted)
+                  (catch Exception e
+                    (-> s (.onError e)))))]
         ; a subscription that cancels the future if unsubscribed
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
+        (.add s (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
-(defn getVideoMetadata [videoId, preferredLanguage]
+(defn getVideoMetadata
   "Asynchronously fetch movie metadata for a given language
   return Observable"
+  [videoId, preferredLanguage]
   (Observable/create
-    (rx/fn [observer]
+    (rx/action [^rx.Subscriber s]
       (let [f (future
+                (println "getVideoMetadata " videoId)
                 (try
                   ; simulate fetching video data via network service call with latency
                   (Thread/sleep 50)
                   ; contrived metadata for en-us or es-us
                   (if (= "en-us" preferredLanguage)
-                    (-> observer (.onNext {:video-id videoId
+                    (-> s (.onNext {:video-id videoId
                                            :title "House of Cards: Episode 1"
                                            :director "David Fincher"
                                            :duration 3365})))
                   (if (= "es-us" preferredLanguage)
-                    (-> observer (.onNext {:video-id videoId
+                    (-> s (.onNext {:video-id videoId
                                            :title "Cámara de Tarjetas: Episodio 1"
                                            :director "David Fincher"
                                            :duration 3365})))
-                  (-> observer .onCompleted)
-                  (catch Exception e (-> observer (.onError e))))) ]
+                  (-> s .onCompleted)
+                  (catch Exception e
+                    (-> s (.onError e))))) ]
         ; a subscription that cancels the future if unsubscribed
-        (Subscriptions/create (rx/action [] (future-cancel f)))))))
+        (.add s (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
 
 (defn getVideoForUser [userId videoId]
@@ -188,8 +179,9 @@
   - user data
   return Observable"
   (let [user-observable           (-> (getUser userId)
-                                    (.map (rx/fn [user] {:user-name (:name user)
-                                                      :language (:preferred-language user)})))
+                                      (.map (rx/fn [user]
+                                              {:user-name (:name user)
+                                               :language (:preferred-language user)})))
         bookmark-observable       (-> (getVideoBookmark userId videoId)
                                     (.map (rx/fn [bookmark] {:viewed-position (:position bookmark)})))
         ; getVideoMetadata requires :language from user-observable so nest inside map function
@@ -218,8 +210,6 @@
 ;
 (comment
   (-> (getVideoForUser 12345 78965)
-    (.subscribe
-      (rx/action [x] (println "--- Object ---\n" x))
-      (rx/action [e] (println "--- Error ---\n" e))
-      (rx/action [] (println "--- Completed ---")))))
+      (.toBlockingObservable)
+      .single))
 
diff --git a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/video_example.clj b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/video_example.clj
index e3fa48fa68..11078aad22 100644
--- a/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/video_example.clj
+++ b/language-adaptors/rxjava-clojure/src/examples/clojure/rx/lang/clojure/examples/video_example.clj
@@ -1,12 +1,12 @@
 ;
 ; 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.
@@ -108,10 +108,10 @@
   "Returns an observable that executes (f observer) in a future, returning a
   subscription that will cancel the future."
   [f]
-  (Observable/create (rx/fn [^Observer observer]
+  (Observable/create (rx/action [^rx.Subscriber s]
                        (println "Starting f")
-                       (let [f (future (f observer))]
-                         (Subscriptions/create (rx/action [] (future-cancel f)))))))
+                       (let [f (future (f s))]
+                         (.add s (Subscriptions/create (rx/action [] (future-cancel f))))))))
 
 (defn ^Observable get-list-of-lists
   "
@@ -120,15 +120,17 @@
   Observable is the \"push\" equivalent to List
   "
   [user-id]
-  (future-observable (fn [^Observer observer]
+  (future-observable (fn [^rx.Subscriber s]
                        (Thread/sleep 180)
                        (dotimes [i 15]
-                         (.onNext observer (video-list i)))
-                       (.onCompleted observer))))
+                         (.onNext s (video-list i)))
+                       (.onCompleted s))))
 
 
-(comment (.subscribe (get-list-of-lists 7777)
-                     (rx/action* println)))
+(comment (-> (get-list-of-lists 7777)
+             .toList
+             .toBlockingObservable
+             .single))
 
 (defn video-list
   [position]
@@ -137,24 +139,28 @@
 
 (defn ^Observable video-list->videos
   [{:keys [position] :as video-list}]
-  (Observable/create (rx/fn [^Observer observer]
+  (Observable/create (rx/action [^rx.Subscriber s]
                        (dotimes [i 50]
-                         (.onNext observer (+ (* position 1000) i)))
-                       (.onCompleted observer)
-                       (Subscriptions/empty))))
+                         (.onNext s (+ (* position 1000) i)))
+                       (.onCompleted s))))
 
-(comment (.subscribe (video-list->videos (video-list 2)) (rx/action* println)))
+(comment (-> (video-list->videos (video-list 2))
+             .toList
+             .toBlockingObservable
+             .single))
 
 (defn ^Observable video->metadata
   [video-id]
-  (Observable/create (rx/fn [^Observer observer]
-                       (.onNext observer {:title (str "video-" video-id "-title")
-                                          :actors ["actor1" "actor2"]
-                                          :duration 5428 })
-                       (.onCompleted observer)
-                       (Subscriptions/empty))))
+  (Observable/create (rx/action [^rx.Subscriber s]
+                                (.onNext s {:title (str "video-" video-id "-title")
+                                            :actors ["actor1" "actor2"]
+                                            :duration 5428 })
+                                (.onCompleted s))))
 
-(comment (.subscribe (video->metadata 10) (rx/action* println)))
+(comment (-> (video->metadata 10)
+             .toList
+             .toBlockingObservable
+             .single))
 
 (defn ^Observable video->bookmark
   [video-id user-id]
@@ -165,7 +171,10 @@
                        (println "onComplete")
                        (.onCompleted observer))))
 
-(comment (.subscribe (video->bookmark 112345 99999) (rx/action* println)))
+(comment (-> (video->bookmark 112345 99999)
+            .toList
+            .toBlockingObservable
+            .single))
 
 (defn ^Observable video->rating
   [video-id user-id]
@@ -178,5 +187,8 @@
                                           :actual-star-rating    (rand-int 5) })
                        (.onCompleted observer))))
 
-(comment (.subscribe (video->rating 234345 8888) (rx/action* println)))
+(comment (-> (video->rating 234345 8888)
+             .toList
+             .toBlockingObservable
+             .single))
 

From 3d9842ff25cf5df85eb82a41e52e78b0c1f26053 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Mon, 27 Jan 2014 15:53:43 -0800
Subject: [PATCH 334/441] Setting up the new subproject for debugging
 observable chains.

---
 rxjava-contrib/rxjava-debug/build.gradle      |  30 ++++
 .../java/rx/operators/DebugSubscriber.java    |  68 +++++++++
 .../java/rx/operators/DebugSubscription.java  |  23 ++++
 .../src/main/java/rx/plugins/DebugHook.java   |  99 +++++++++++++
 .../java/rx/plugins/DebugNotification.java    | 109 +++++++++++++++
 .../java/rx/plugins/NotificationEvent.java    | 104 ++++++++++++++
 .../src/test/java/rx/debug/DebugHookTest.java | 130 ++++++++++++++++++
 .../src/test/java/rx/plugins/PlugReset.java   |   7 +
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/observers/SafeSubscriber.java     |   3 +
 .../RxJavaObservableExecutionHook.java        |  13 +-
 .../main/java/rx/util/functions/Actions.java  |  53 ++++++-
 settings.gradle                               |   1 +
 13 files changed, 642 insertions(+), 4 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-debug/build.gradle
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
 create mode 100644 rxjava-contrib/rxjava-debug/src/test/java/rx/plugins/PlugReset.java

diff --git a/rxjava-contrib/rxjava-debug/build.gradle b/rxjava-contrib/rxjava-debug/build.gradle
new file mode 100644
index 0000000000..13775cd88e
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/build.gradle
@@ -0,0 +1,30 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    testCompile project(":rxjava-core").sourceSets.test.output 
+    provided 'junit:junit-dep:4.10'
+    provided 'org.mockito:mockito-core:1.8.5'
+}
+
+javadoc {
+    options {
+        doclet = "org.benjchristensen.doclet.DocletExclude"
+        docletpath = [rootProject.file('./gradle/doclet-exclude.jar')]
+        stylesheetFile = rootProject.file('./gradle/javadocStyleSheet.css')
+        windowTitle = "RxJava Javadoc ${project.version}"
+    }
+    options.addStringOption('top').value = '
    RxJava
    '
+}
+
+jar {
+    manifest {
+        name = 'rxjava-debug'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+    }
+}
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
new file mode 100644
index 0000000000..5e17cb9151
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
@@ -0,0 +1,68 @@
+package rx.operators;
+
+import rx.Observer;
+import rx.Subscriber;
+import rx.plugins.DebugNotification;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public final class DebugSubscriber extends Subscriber {
+    private final Func1 onNextHook;
+    final Action1 events;
+    final Observer o;
+    Operator from = null;
+    Operator to = null;
+
+    public DebugSubscriber(
+            Func1 onNextHook,
+            Action1 _events,
+            Subscriber _o,
+            Operator _out,
+            Operator _in) {
+        super(_o);
+        this.events = _events;
+        this.o = _o;
+        this.onNextHook = onNextHook;
+        this.from = _out;
+        this.to = _in;
+        this.add(new DebugSubscription(this));
+    }
+
+    @Override
+    public void onCompleted() {
+        events.call(DebugNotification.createOnCompleted(o, from, to));
+        o.onCompleted();
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        events.call(DebugNotification.createOnError(o, from, e, to));
+        o.onError(e);
+    }
+
+    @Override
+    public void onNext(T t) {
+        events.call(DebugNotification.createOnNext(o, from, t, to));
+        o.onNext(onNextHook.call(t));
+    }
+
+    public Operator getFrom() {
+        return from;
+    }
+
+    public void setFrom(Operator op) {
+        this.from = op;
+    }
+
+    public Operator getTo() {
+        return to;
+    }
+
+    public void setTo(Operator op) {
+        this.to = op;
+    }
+
+    public Observer getActual() {
+        return o;
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
new file mode 100644
index 0000000000..e82960d5fe
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
@@ -0,0 +1,23 @@
+package rx.operators;
+
+import rx.Subscription;
+import rx.plugins.DebugNotification;
+
+final class DebugSubscription implements Subscription {
+    private final DebugSubscriber debugObserver;
+
+    DebugSubscription(DebugSubscriber debugObserver) {
+        this.debugObserver = debugObserver;
+    }
+
+    @Override
+    public void unsubscribe() {
+        debugObserver.events.call(DebugNotification. createUnsubscribe(debugObserver.o, debugObserver.from, debugObserver.to));
+        debugObserver.unsubscribe();
+    }
+
+    @Override
+    public boolean isUnsubscribed() {
+        return debugObserver.isUnsubscribed();
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
new file mode 100644
index 0000000000..f530de6e79
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
@@ -0,0 +1,99 @@
+package rx.plugins;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.operators.DebugSubscriber;
+import rx.operators.Operator;
+import rx.util.functions.Action1;
+import rx.util.functions.Actions;
+import rx.util.functions.Func1;
+import rx.util.functions.Functions;
+
+/**
+ * Implements hooks into the {@link Observable} chain to emit a detailed account of all the events
+ * that happened.
+ * 
+ * @author gscampbell
+ */
+public class DebugHook extends RxJavaObservableExecutionHook {
+    private final Func1 onNextHook;
+    private final Action1 events;
+
+    /**
+     * Creates a new instance of the DebugHook RxJava plug-in that can be passed into
+     * {@link RxJavaPlugins} registerObservableExecutionHook(hook) method.
+     * 
+     * @param onNextDataHook
+     *            all of the onNext values are passed through this function to allow for
+     *            manipulation of the values
+     * @param events
+     *            This action is invoked as each notification is generated
+     */
+    public DebugHook(Func1 onNextDataHook, Action1 events) {
+        this.onNextHook = onNextDataHook == null ? Functions.identity() : onNextDataHook;
+        this.events = events == null ? Actions.empty() : events;
+    }
+
+    @Override
+    public  OnSubscribe onSubscribeStart(Observable observableInstance, final OnSubscribe f) {
+        return new OnSubscribe() {
+            @Override
+            public void call(Subscriber o) {
+                events.call(DebugNotification.createSubscribe(o, f));
+                f.call(wrapOutbound(null, o));
+            }
+        };
+    }
+
+    @Override
+    public  Subscription onSubscribeReturn(Observable observableInstance, Subscription subscription) {
+        return subscription;
+    }
+
+    @Override
+    public  OnSubscribe onCreate(final OnSubscribe f) {
+        return new OnSubscribe() {
+            @Override
+            public void call(Subscriber o) {
+                f.call(wrapInbound(null, o));
+            }
+        };
+    }
+
+    @Override
+    public  Operator onLift(final Operator bind) {
+        return new Operator() {
+            @Override
+            public Subscriber call(final Subscriber o) {
+                return wrapInbound(bind, bind.call(wrapOutbound(bind, o)));
+            }
+        };
+    }
+
+    @Override
+    public  Subscription onAdd(Subscriber subscriber, Subscription s) {
+        return s;
+    }
+
+    @SuppressWarnings("unchecked")
+    private  Subscriber wrapOutbound(Operator bind, Subscriber o) {
+        if (o instanceof DebugSubscriber) {
+            if (bind != null)
+                ((DebugSubscriber) o).setFrom(bind);
+            return o;
+        }
+        return new DebugSubscriber(onNextHook, events, o, bind, null);
+    }
+
+    @SuppressWarnings("unchecked")
+    private  Subscriber wrapInbound(Operator bind, Subscriber o) {
+        if (o instanceof DebugSubscriber) {
+            if (bind != null)
+                ((DebugSubscriber) o).setTo(bind);
+            return o;
+        }
+        return new DebugSubscriber(onNextHook, events, o, null, bind);
+    }
+}
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
new file mode 100644
index 0000000000..af66b94217
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
@@ -0,0 +1,109 @@
+package rx.plugins;
+
+import rx.Notification;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.observers.SafeSubscriber;
+import rx.operators.DebugSubscriber;
+import rx.operators.Operator;
+import rx.plugins.DebugNotification.Kind;
+
+public class DebugNotification {
+    public static enum Kind {
+        OnNext, OnError, OnCompleted, Subscribe, Unsubscribe
+    }
+
+    private final OnSubscribe source;
+    private final Operator from;
+    private final Kind kind;
+    private final Notification notification;
+    private final Operator to;
+    private final long nanoTime;
+    private final long threadId;
+    private Observer o;
+
+    public static  DebugNotification createSubscribe(Observer o, OnSubscribe source) {
+        Operator to = null;
+        Operator from = null;
+        if (o instanceof DebugSubscriber) {
+            to = ((DebugSubscriber) o).getTo();
+            from = ((DebugSubscriber) o).getFrom();
+            o = ((DebugSubscriber) o).getActual();
+        }
+        return new DebugNotification(o, from, Kind.Subscribe, null, to, source);
+    }
+
+    public static  DebugNotification createOnNext(Observer o, Operator from, T t, Operator to) {
+        return new DebugNotification(o, from, Kind.OnNext, Notification.createOnNext(t), to, null);
+    }
+
+    public static  DebugNotification createOnError(Observer o, Operator from, Throwable e, Operator to) {
+        return new DebugNotification(o, from, Kind.OnError, Notification. createOnError(e), to, null);
+    }
+
+    public static  DebugNotification createOnCompleted(Observer o, Operator from, Operator to) {
+        return new DebugNotification(o, from, Kind.OnCompleted, Notification. createOnCompleted(), to, null);
+    }
+
+    public static  DebugNotification createUnsubscribe(Observer o, Operator from, Operator to) {
+        return new DebugNotification(o, from, Kind.Unsubscribe, null, to, null);
+    }
+
+    private DebugNotification(Observer o, Operator from, Kind kind, Notification notification, Operator to, OnSubscribe source) {
+        this.o = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
+        this.from = from;
+        this.kind = kind;
+        this.notification = notification;
+        this.to = to;
+        this.source = source;
+        this.nanoTime = System.nanoTime();
+        this.threadId = Thread.currentThread().getId();
+    }
+
+    public Operator getFrom() {
+        return from;
+    }
+
+    public Notification getNotification() {
+        return notification;
+    }
+
+    public Operator getTo() {
+        return to;
+    }
+
+    public long getNanoTime() {
+        return nanoTime;
+    }
+
+    public long getThreadId() {
+        return threadId;
+    }
+
+    public Kind getKind() {
+        return kind;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder s = new StringBuilder("{");
+        s.append(" \"nano\": ").append(nanoTime);
+        s.append(", \"thread\": ").append(threadId);
+        s.append(", \"observer\": \"").append(o.getClass().getName()).append("@").append(Integer.toHexString(o.hashCode())).append("\"");
+        s.append(", \"type\": \"").append(kind).append("\"");
+        if (notification != null) {
+            if (notification.hasValue())
+                s.append(", \"value\": \"").append(notification.getValue()).append("\"");
+            if (notification.hasThrowable())
+                s.append(", \"exception\": \"").append(notification.getThrowable().getMessage().replace("\\", "\\\\").replace("\"", "\\\"")).append("\"");
+        }
+        if (source != null)
+            s.append(", \"source\": \"").append(source.getClass().getName()).append("@").append(Integer.toHexString(source.hashCode())).append("\"");
+        if (from != null)
+            s.append(", \"from\": \"").append(from.getClass().getName()).append("@").append(Integer.toHexString(from.hashCode())).append("\"");
+        if (to != null)
+            s.append(", \"to\": \"").append(to.getClass().getName()).append("@").append(Integer.toHexString(to.hashCode())).append("\"");
+        s.append("}");
+        return s.toString();
+    }
+}
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
new file mode 100644
index 0000000000..998c562529
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
@@ -0,0 +1,104 @@
+package rx.plugins;
+
+import rx.Notification;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.observers.SafeSubscriber;
+import rx.operators.DebugSubscriber;
+import rx.operators.Operator;
+
+public class NotificationEvent {
+    public static enum Kind {
+        OnNext, OnError, OnCompleted, Subscribe, Unsubscribe
+    }
+
+    private final OnSubscribe source;
+    private final Operator from;
+    private final Kind kind;
+    private final Notification notification;
+    private final Operator to;
+    private final long nanoTime;
+    private final long threadId;
+    private Observer o;
+
+    public static  NotificationEvent createSubscribe(Observer o, OnSubscribe source) {
+        Operator to = null;
+        Operator from = null;
+        if (o instanceof DebugSubscriber) {
+            to = ((DebugSubscriber) o).getTo();
+            from = ((DebugSubscriber) o).getFrom();
+            o = ((DebugSubscriber) o).getActual();
+        }
+        return new NotificationEvent(o, from, Kind.Subscribe, null, to, source);
+    }
+
+    public static  NotificationEvent createOnNext(Observer o, Operator from, T t, Operator to) {
+        return new NotificationEvent(o, from, Kind.OnNext, Notification.createOnNext(t), to, null);
+    }
+
+    public static  NotificationEvent createOnError(Observer o, Operator from, Throwable e, Operator to) {
+        return new NotificationEvent(o, from, Kind.OnError, Notification. createOnError(e), to, null);
+    }
+
+    public static  NotificationEvent createOnCompleted(Observer o, Operator from, Operator to) {
+        return new NotificationEvent(o, from, Kind.OnCompleted, Notification. createOnCompleted(), to, null);
+    }
+
+    public static  NotificationEvent createUnsubscribe(Observer o, Operator from, Operator to) {
+        return new NotificationEvent(o, from, Kind.Unsubscribe, null, to, null);
+    }
+
+    private NotificationEvent(Observer o, Operator from, Kind kind, Notification notification, Operator to, OnSubscribe source) {
+        this.o = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
+        this.from = from;
+        this.kind = kind;
+        this.notification = notification;
+        this.to = to;
+        this.source = source;
+        this.nanoTime = System.nanoTime();
+        this.threadId = Thread.currentThread().getId();
+    }
+
+    public Operator getFrom() {
+        return from;
+    }
+
+    public Notification getNotification() {
+        return notification;
+    }
+
+    public Operator getTo() {
+        return to;
+    }
+
+    public long getNanoTime() {
+        return nanoTime;
+    }
+
+    public long getThreadId() {
+        return threadId;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder s = new StringBuilder("{");
+        s.append(" \"nano\": ").append(nanoTime);
+        s.append(", \"thread\": ").append(threadId);
+        s.append(", \"observer\": \"").append(o.getClass().getName()).append("@").append(Integer.toHexString(o.hashCode())).append("\"");
+        s.append(", \"type\": \"").append(kind).append("\"");
+        if (notification != null) {
+            if (notification.hasValue())
+                s.append(", \"value\": \"").append(notification.getValue()).append("\"");
+            if (notification.hasThrowable())
+                s.append(", \"exception\": \"").append(notification.getThrowable().getMessage().replace("\\", "\\\\").replace("\"", "\\\"")).append("\"");
+        }
+        if (source != null)
+            s.append(", \"source\": \"").append(source.getClass().getName()).append("@").append(Integer.toHexString(source.hashCode())).append("\"");
+        if (from != null)
+            s.append(", \"from\": \"").append(from.getClass().getName()).append("@").append(Integer.toHexString(from.hashCode())).append("\"");
+        if (to != null)
+            s.append(", \"to\": \"").append(to.getClass().getName()).append("@").append(Integer.toHexString(to.hashCode())).append("\"");
+        s.append("}");
+        return s.toString();
+    }
+}
diff --git a/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
new file mode 100644
index 0000000000..e90de3c11f
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
@@ -0,0 +1,130 @@
+package rx.debug;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import rx.Notification;
+import rx.Observable;
+import rx.Observer;
+import rx.plugins.DebugHook;
+import rx.plugins.DebugNotification;
+import rx.plugins.PlugReset;
+import rx.plugins.RxJavaPlugins;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public class DebugHookTest {
+    @Before
+    @After
+    public void reset() {
+        PlugReset.reset();
+    }
+
+    @Test
+    @Ignore
+    public void testSimple() {
+        Action1 events = mock(Action1.class);
+        final DebugHook hook = new DebugHook(null, events);
+        RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
+        Observable.empty().subscribe();
+        verify(events, times(1)).call(subscribe());
+        verify(events, times(1)).call(onCompleted());
+    }
+
+    @Test
+    public void testOneOp() {
+        Action1 events = mock(Action1.class);
+        final DebugHook hook = new DebugHook(null, events);
+        RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
+        Observable.from(Arrays.asList(1, 3)).flatMap(new Func1>() {
+            @Override
+            public Observable call(Integer it) {
+                return Observable.from(Arrays.asList(it, it + 1));
+            }
+        }).take(3).subscribe(new Observer() {
+            @Override
+            public void onCompleted() {
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onNext(Integer t) {
+            }
+        });
+        verify(events, times(6)).call(subscribe());
+        verify(events, times(4)).call(onNext(1));
+        // one less because it originates from the inner observable sent to merge
+        verify(events, times(3)).call(onNext(2));
+        verify(events, times(4)).call(onNext(3));
+        // because the take unsubscribes
+        verify(events, never()).call(onNext(4));
+    }
+
+    private static  DebugNotification onNext(final T value) {
+        return argThat(new BaseMatcher>() {
+            @Override
+            public boolean matches(Object item) {
+                if (item instanceof DebugNotification) {
+                    DebugNotification dn = (DebugNotification) item;
+                    Notification n = dn.getNotification();
+                    return n != null && n.hasValue() && n.getValue().equals(value);
+                }
+                return false;
+            }
+
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("OnNext " + value);
+            }
+        });
+    }
+
+    private static DebugNotification subscribe() {
+        return argThat(new BaseMatcher() {
+            @Override
+            public boolean matches(Object item) {
+                if (item instanceof DebugNotification) {
+                    DebugNotification dn = (DebugNotification) item;
+                    return dn.getKind() == DebugNotification.Kind.Subscribe;
+                }
+                return false;
+            }
+
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("Subscribe");
+            }
+        });
+    }
+
+    private static DebugNotification onCompleted() {
+        return argThat(new BaseMatcher() {
+            @Override
+            public boolean matches(Object item) {
+                if (item instanceof DebugNotification) {
+                    DebugNotification dn = (DebugNotification) item;
+                    Notification n = dn.getNotification();
+                    return n != null && n.isOnCompleted();
+                }
+                return false;
+            }
+
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("onCompleted");
+            }
+        });
+    }
+}
diff --git a/rxjava-contrib/rxjava-debug/src/test/java/rx/plugins/PlugReset.java b/rxjava-contrib/rxjava-debug/src/test/java/rx/plugins/PlugReset.java
new file mode 100644
index 0000000000..0292d1b5e3
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/test/java/rx/plugins/PlugReset.java
@@ -0,0 +1,7 @@
+package rx.plugins;
+
+public class PlugReset {
+    public static void reset() {
+        RxJavaPlugins.getInstance().reset();
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 542bedbff2..3794f33476 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -27,6 +27,7 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
+import rx.Observable.OnSubscribe;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
 import rx.observables.BlockingObservable;
@@ -49,6 +50,7 @@
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
+import rx.operators.Operator;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperationElementAt;
 import rx.operators.OperationFilter;
@@ -98,6 +100,7 @@
 import rx.operators.OperationWindow;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorZip;
+import rx.operators.Operator;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorFromIterable;
 import rx.operators.OperatorGroupBy;
@@ -251,10 +254,9 @@ public static interface OnSubscribeFunc extends Function {
      */
     public  Observable lift(final Func1, Subscriber> bind) {
         return new Observable(new OnSubscribe() {
-
             @Override
             public void call(Subscriber o) {
-                subscribe(bind.call(o));
+                subscribe(hook.onLift((Operator) bind).call(o));
             }
         });
     }
diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index a7ce075ef5..23255df38d 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -157,4 +157,7 @@ protected void _onError(Throwable e) {
         }
     }
 
+    public Subscriber getActual() {
+        return actual;
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index c3aa2b44ad..da4500c494 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -20,6 +20,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.operators.Operator;
 import rx.util.functions.Func1;
 
 /**
@@ -37,7 +38,6 @@
  * 
  * */
 public abstract class RxJavaObservableExecutionHook {
-
     /**
      * Invoked before {@link Observable#subscribe(rx.Subscriber)} is about to be executed.
      * 
    
@@ -93,4 +93,15 @@ public  Throwable onSubscribeError(Observable observableInstance
         return e;
     }
 
+    public  OnSubscribe onCreate(OnSubscribe f) {
+        return f;
+    }
+
+    public  Operator onLift(final Operator bind) {
+        return bind;
+    }
+
+    public  Subscription onAdd(Subscriber subscriber, Subscription s) {
+        return s;
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/util/functions/Actions.java b/rxjava-core/src/main/java/rx/util/functions/Actions.java
index 5d4d3656dc..7b233bb7fb 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Actions.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Actions.java
@@ -16,7 +16,6 @@
 package rx.util.functions;
 
 import rx.Observer;
-import rx.Subscriber;
 
 /**
  * Utility class for the Action interfaces.
@@ -26,6 +25,58 @@ private Actions() {
         throw new IllegalStateException("No instances!");
     }
 
+    public static final EmptyAction empty() {
+        return EMPTY_ACTION;
+    }
+
+    private static final EmptyAction EMPTY_ACTION = new EmptyAction();
+
+    private static final class EmptyAction implements Action0, Action1, Action2, Action3, Action4, Action5, Action6, Action7, Action8, Action9, ActionN {
+        @Override
+        public void call() {
+        }
+
+        @Override
+        public void call(Object t1) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8, Object t9) {
+        }
+
+        @Override
+        public void call(Object... args) {
+        }
+    }
+    
     /**
      * Extracts a method reference to the observer's onNext method
      * in the form of an Action1.
diff --git a/settings.gradle b/settings.gradle
index 2122bb8ff6..a657ce5ba9 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,5 +9,6 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
+'rxjava-contrib:rxjava-debug', \
 'rxjava-contrib:rxjava-async-util', \
 'rxjava-contrib:rxjava-computation-expressions'

From d012a528ed2cbf59dfebefc57c904dc1ee29a12a Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Fri, 7 Feb 2014 00:46:00 -0800
Subject: [PATCH 335/441] Small change to convert from Caliper to JMH.

---
 build.gradle                                  |  3 +-
 rxjava-core/build.gradle                      |  5 --
 .../rx/operators/ObservableBenchmark.java     | 52 +++++++++++--------
 3 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/build.gradle b/build.gradle
index b17f618a30..304a26643c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -54,8 +54,7 @@ subprojects {
     }
 
     dependencies {
-        perfCompile 'com.google.caliper:caliper:1.0-beta-1'
-        perfRuntime 'com.sun.jersey:jersey-core:1.11'
+        perfCompile 'org.openjdk.jmh:jmh-core:0.2'
     }
 
     tasks.build { 
diff --git a/rxjava-core/build.gradle b/rxjava-core/build.gradle
index 04e4bd7987..8cd94496a6 100644
--- a/rxjava-core/build.gradle
+++ b/rxjava-core/build.gradle
@@ -33,13 +33,8 @@ jar {
 }
 
 task time(type:JavaExec) {
-    //sourceSets.metaClass.methods.each { println it }
     classpath = sourceSets.perf.runtimeClasspath
     group 'Application'
     description 'Execute the calipser benchmark timing of Rx'
     main 'rx.operators.ObservableBenchmark'
-    // args '--print-config' // dump the caliper configuration before starting
-    // args '--verbose' // uncomment to have caliper log what it's doing
-    args '--trials=1' // only run the experiments once
-    //args '--time-limit=0' // experiments never timeout
 }
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
index 9bb4d5e22f..3cfac3d3a5 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -3,51 +3,59 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.util.functions.Func1;
 
-import com.google.caliper.Benchmark;
-import com.google.caliper.runner.CaliperMain;
+public class ObservableBenchmark {
 
-public class ObservableBenchmark extends Benchmark {
-    public void timeBaseline(int reps) {
-        for (int i = 0; i < reps; i++) {
-            observableOfInts.subscribe(newObserver());
-        }
+    @GenerateMicroBenchmark
+    public void timeBaseline() {
+        observableOfInts.subscribe(newObserver());
         awaitAllObservers();
     }
 
-    public int timeMapIterate(long reps) {
+    @GenerateMicroBenchmark
+    public int timeMapIterate() {
         int x = 0;
-        for (int i = 0; i < reps; i++) {
-            for (int j = 0; j < intValues.length; j++) {
-                // use hash code to make sure the JIT doesn't optimize too much and remove all of
-                // our code.
-                x |= ident.call(intValues[j]).hashCode();
-            }
+        for (int j = 0; j < intValues.length; j++) {
+            // use hash code to make sure the JIT doesn't optimize too much and remove all of
+            // our code.
+            x |= ident.call(intValues[j]).hashCode();
         }
         return x;
     }
 
-    public void timeMap(long reps) {
-        timeOperator(reps, new OperatorMap(ident));
+    @GenerateMicroBenchmark
+    public void timeMap() {
+        timeOperator(new OperatorMap(ident));
     }
 
     /**************************************************************************
      * Below is internal stuff to avoid object allocation and time overhead of anything that isn't
      * being tested.
+     * 
+     * @throws RunnerException
      **************************************************************************/
 
-    public static void main(String[] args) {
-        CaliperMain.main(ObservableBenchmark.class, args);
+    public static void main(String[] args) throws RunnerException {
+        Options opt = new OptionsBuilder()
+                .include(ObservableBenchmark.class.getName()+".*")
+                .forks(1)
+                .build();
+
+        new Runner(opt).run();
     }
 
-    private void timeOperator(long reps, Operator op) {
-        for (int i = 0; i < reps; i++) {
-            observableOfInts.lift(op).subscribe(newObserver());
-        }
+    private void timeOperator(Operator op) {
+        observableOfInts.lift(op).subscribe(newObserver());
         awaitAllObservers();
     }
 

From 8f9a04e06438608fff04c728e3aa5c80bfc4fa51 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter 
Date: Sat, 8 Feb 2014 00:46:14 +0100
Subject: [PATCH 336/441] make Scala OnCompleted Notification an object instead
 of a class

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 12 ++++++--
 .../scala/rx/lang/scala/Notification.scala    | 29 ++++---------------
 .../rx/lang/scala/NotificationTests.scala     |  6 ++--
 3 files changed, 19 insertions(+), 28 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
index 4978a526e4..9078a0706f 100644
--- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
+++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
@@ -404,7 +404,7 @@ class RxScalaDemo extends JUnitSuite {
       import Notification._
       o.materialize.subscribe(n => n match {
         case OnNext(v) => println("Got value " + v)
-        case OnCompleted() => println("Completed")
+        case OnCompleted => println("Completed")
         case OnError(err) => println("Error: " + err.getMessage)
       })
     }
@@ -420,11 +420,19 @@ class RxScalaDemo extends JUnitSuite {
     import Notification._
     List(1, 2, 3).toObservable.materialize.subscribe(n => n match {
       case OnNext(v) => println("Got value " + v)
-      case OnCompleted() => println("Completed")
+      case OnCompleted => println("Completed")
       case OnError(err) => println("Error: " + err.getMessage)
     })
   }
 
+  @Test def notificationSubtyping() {
+    import Notification._
+    val oc1: Notification[Nothing] = OnCompleted
+    val oc2: Notification[Int] = OnCompleted
+    val oc3: rx.Notification[_ <: Int] = oc2.asJavaNotification
+    val oc4: rx.Notification[_ <: Any] = oc2.asJavaNotification
+  }
+  
   @Test def elementAtReplacement() {
     assertEquals("b", List("a", "b", "c").toObservable.drop(1).first.toBlockingObservable.single)
   }
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
index c03ead4a4f..84f1642dbc 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala
@@ -41,7 +41,7 @@ sealed trait Notification[+T] {
     this match {
       case Notification.OnNext(value)  => onNext(value)
       case Notification.OnError(error) => onError(error)
-      case Notification.OnCompleted()  => onCompleted()
+      case Notification.OnCompleted  => onCompleted()
     }
   }
 
@@ -58,7 +58,7 @@ sealed trait Notification[+T] {
     this match {
       case Notification.OnNext(value)  => observer.onNext(value)
       case Notification.OnError(error) => observer.onError(error)
-      case Notification.OnCompleted()  => observer.onCompleted()
+      case Notification.OnCompleted  => observer.onCompleted()
     }
   }
 
@@ -82,7 +82,7 @@ object Notification {
 
   private [scala] def apply[T](n: rx.Notification[_ <: T]): Notification[T] = n.getKind match {
     case rx.Notification.Kind.OnNext => new OnNext(n)
-    case rx.Notification.Kind.OnCompleted => new OnCompleted(n)
+    case rx.Notification.Kind.OnCompleted => OnCompleted
     case rx.Notification.Kind.OnError => new OnError(n)
   }
   
@@ -150,26 +150,9 @@ object Notification {
     override def toString = s"OnError($error)"
   }
 
-  object OnCompleted {
-
-    /**
-     * Constructor for onCompleted notifications.
-     */
-    def apply[T](): Notification[T] = {
-      Notification(rx.Notification.createOnCompleted[T]())
-    }
-
-    /**
-     * Extractor for onCompleted notifications.
-     */
-    def unapply[U](notification: Notification[U]): Option[Unit] = notification match {
-      case onCompleted: OnCompleted[U] => Some()
-      case _ => None
-    }
-  }
-
-  class OnCompleted[T] private[scala](val asJavaNotification: rx.Notification[_ <: T]) extends Notification[T] {
-    override def toString = "OnCompleted()"
+  object OnCompleted extends Notification[Nothing] {
+    override def toString = "OnCompleted"
+    val asJavaNotification = rx.Notification.createOnCompleted[Nothing]()
   }
 
 }
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala
index ea05faa942..354fd71a5c 100644
--- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala
+++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/NotificationTests.scala
@@ -37,8 +37,8 @@ class NotificationTests extends JUnitSuite {
     val onError = OnError(oops)
       assertEquals(oops, onError match { case OnError(error) => error })
 
-    val onCompleted = OnCompleted()
-      assertEquals((), onCompleted match { case OnCompleted() => () })
+    val onCompleted = OnCompleted
+      assertEquals((), onCompleted match { case OnCompleted => () })
   }
 
   @Test
@@ -51,7 +51,7 @@ class NotificationTests extends JUnitSuite {
     val onError = OnError(oops)
       assertEquals(4711, onError(x=>42, e=>4711,()=>13))
 
-    val onCompleted = OnCompleted()
+    val onCompleted = OnCompleted
       assertEquals(13, onCompleted(x=>42, e=>4711,()=>13))
 
   }

From 2a4e9c6786a9afaa394ead3ba802a24634a27fe5 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 7 Feb 2014 21:51:29 -0800
Subject: [PATCH 337/441] Special Handling of java.lang.Error and
 OnErrorNotImplemented

- https://github.com/Netflix/RxJava/issues/748#issuecomment-32471495
- https://github.com/Netflix/RxJava/issues/771
- https://github.com/Netflix/RxJava/issues/789

- SynchronizedObserver is for synchronization, not error handling or contract enforcements, that's the job of SafeSubscriber
- Removed some unit tests that were asserting unsubscribe behavior that relied on SynchronizedObserver. They were testing something they are not responsible for.
---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/observers/SafeSubscriber.java     |  13 +-
 .../rx/observers/SynchronizedObserver.java    |  58 +--
 .../rx/observers/SynchronizedSubscriber.java  |   5 +-
 .../operators/OperationMergeDelayError.java   |   4 +-
 .../rx/operators/OperationSynchronize.java    |   7 +-
 .../main/java/rx/operators/OperationZip.java  | 446 ------------------
 .../src/main/java/rx/util/Exceptions.java     |  15 +
 .../observers/SynchronizedObserverTest.java   |  26 +-
 .../OperationMergeDelayErrorTest.java         |  27 --
 .../java/rx/operators/OperatorMapTest.java    |  49 ++
 ...onizeTest.java => SafeSubscriberTest.java} |  84 +---
 .../test/java/rx/util/AssertObservable.java   |  12 +-
 .../src/test/java/rx/util/ExceptionsTest.java | 137 ++++++
 14 files changed, 250 insertions(+), 639 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationZip.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSynchronizeTest.java => SafeSubscriberTest.java} (64%)
 create mode 100644 rxjava-core/src/test/java/rx/util/ExceptionsTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 542bedbff2..3d672326e5 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -118,6 +118,7 @@
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
+import rx.util.Exceptions;
 import rx.util.OnErrorNotImplementedException;
 import rx.util.Range;
 import rx.util.TimeInterval;
@@ -6964,10 +6965,9 @@ public void call() {
                 }
 
             });
-        } catch (OnErrorNotImplementedException e) {
-            // special handling when onError is not implemented ... we just rethrow
-            throw e;
         } catch (Throwable e) {
+            // special handling for certain Throwable/Error/Exception types
+            Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
                 observer.onError(hook.onSubscribeError(this, e));
diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index a7ce075ef5..d757d85251 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -19,11 +19,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Subscriber;
-import rx.Subscription;
-import rx.operators.SafeObservableSubscription;
 import rx.plugins.RxJavaPlugins;
-import rx.subscriptions.Subscriptions;
 import rx.util.CompositeException;
+import rx.util.Exceptions;
 import rx.util.OnErrorNotImplementedException;
 
 /**
@@ -74,6 +72,9 @@ public void onCompleted() {
             try {
                 actual.onCompleted();
             } catch (Throwable e) {
+                // we handle here instead of another method so we don't add stacks to the frame
+                // which can prevent it from being able to handle StackOverflow
+                Exceptions.throwIfFatal(e);
                 // handle errors if the onCompleted implementation fails, not just if the Observable fails
                 _onError(e);
             } finally {
@@ -85,6 +86,9 @@ public void onCompleted() {
 
     @Override
     public void onError(Throwable e) {
+        // we handle here instead of another method so we don't add stacks to the frame
+        // which can prevent it from being able to handle StackOverflow
+        Exceptions.throwIfFatal(e);
         if (isFinished.compareAndSet(false, true)) {
             _onError(e);
         }
@@ -97,6 +101,9 @@ public void onNext(T args) {
                 actual.onNext(args);
             }
         } catch (Throwable e) {
+            // we handle here instead of another method so we don't add stacks to the frame
+            // which can prevent it from being able to handle StackOverflow
+            Exceptions.throwIfFatal(e);
             // handle errors if the onNext implementation fails, not just if the Observable fails
             onError(e);
         }
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
index ad18e6a2eb..eedecd1368 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
@@ -16,18 +16,11 @@
 package rx.observers;
 
 import rx.Observer;
-import rx.Subscriber;
-import rx.operators.SafeObservableSubscription;
 
 /**
- * A thread-safe Observer for transitioning states in operators.
+ * Synchronize execution to be single-threaded.
  * 
    
- * Execution rules are:
- * 
      
- * 
    • Allow only single-threaded, synchronous, ordered execution of onNext, onCompleted, onError
      • 
- * 
    • Once an onComplete or onError are performed, no further calls can be executed
      • 
- * 
    • If unsubscribe is called, this means we call completed() and don't allow any further onNext calls.
      • 
- * 
    
+ * This ONLY does synchronization. It does not involve itself in safety or subscriptions. See SafeSubscriber for that.
  * 
  * @param 
  */
@@ -48,76 +41,33 @@ public final class SynchronizedObserver implements Observer {
      */
 
     private final Observer observer;
-    private final SafeObservableSubscription subscription;
-    private volatile boolean finishRequested = false;
-    private volatile boolean finished = false;
     private volatile Object lock;
 
-    public SynchronizedObserver(Observer subscriber, SafeObservableSubscription subscription) {
+    public SynchronizedObserver(Observer subscriber) {
         this.observer = subscriber;
-        this.subscription = subscription;
         this.lock = this;
     }
 
-    public SynchronizedObserver(Observer subscriber, SafeObservableSubscription subscription, Object lock) {
+    public SynchronizedObserver(Observer subscriber, Object lock) {
         this.observer = subscriber;
-        this.subscription = subscription;
         this.lock = lock;
     }
 
-    /**
-     * Used when synchronizing an Observer without access to the subscription.
-     * 
-     * @param Observer
-     */
-    public SynchronizedObserver(Observer subscriber) {
-        this(subscriber, new SafeObservableSubscription());
-    }
-
     public void onNext(T arg) {
-        if (finished || finishRequested || subscription.isUnsubscribed()) {
-            // if we're already stopped, or a finish request has been received, we won't allow further onNext requests
-            return;
-        }
         synchronized (lock) {
-            // check again since this could have changed while waiting
-            if (finished || finishRequested || subscription.isUnsubscribed()) {
-                // if we're already stopped, or a finish request has been received, we won't allow further onNext requests
-                return;
-            }
             observer.onNext(arg);
         }
     }
 
     public void onError(Throwable e) {
-        if (finished || subscription.isUnsubscribed()) {
-            // another thread has already finished us, so we won't proceed
-            return;
-        }
-        finishRequested = true;
         synchronized (lock) {
-            // check again since this could have changed while waiting
-            if (finished || subscription.isUnsubscribed()) {
-                return;
-            }
             observer.onError(e);
-            finished = true;
         }
     }
 
     public void onCompleted() {
-        if (finished || subscription.isUnsubscribed()) {
-            // another thread has already finished us, so we won't proceed
-            return;
-        }
-        finishRequested = true;
         synchronized (lock) {
-            // check again since this could have changed while waiting
-            if (finished || subscription.isUnsubscribed()) {
-                return;
-            }
             observer.onCompleted();
-            finished = true;
         }
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
index 54eef0f8cc..8c01f506e1 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
@@ -17,7 +17,6 @@
 
 import rx.Observer;
 import rx.Subscriber;
-import rx.operators.SafeObservableSubscription;
 
 /**
  * A thread-safe Observer for transitioning states in operators.
@@ -37,9 +36,7 @@ public final class SynchronizedSubscriber extends Subscriber {
 
     public SynchronizedSubscriber(Subscriber subscriber, Object lock) {
         super(subscriber);
-        SafeObservableSubscription s = new SafeObservableSubscription();
-        subscriber.add(s);
-        this.observer = new SynchronizedObserver(subscriber, s, lock);
+        this.observer = new SynchronizedObserver(subscriber, lock);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index d36225a5ed..7a31593d99 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -151,9 +151,7 @@ public Subscription onSubscribe(Observer actualObserver) {
              * 
    
              * Bug report: https://github.com/Netflix/RxJava/issues/614
              */
-            SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription);
-            completeSubscription.add(subscription);
-            SynchronizedObserver synchronizedObserver = new SynchronizedObserver(actualObserver, subscription);
+            SynchronizedObserver synchronizedObserver = new SynchronizedObserver(actualObserver);
 
             /**
              * Subscribe to the parent Observable to get to the children Observables
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
index a13fbab9cb..e94411b313 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
@@ -86,14 +86,13 @@ public Synchronize(Observable innerObservable, Object lock) {
         private Object lock;
 
         public Subscription onSubscribe(Observer observer) {
-            SafeObservableSubscription subscription = new SafeObservableSubscription();
             if (lock == null) {
-                atomicObserver = new SynchronizedObserver(observer, subscription);
+                atomicObserver = new SynchronizedObserver(observer);
             }
             else {
-                atomicObserver = new SynchronizedObserver(observer, subscription, lock);
+                atomicObserver = new SynchronizedObserver(observer, lock);
             }
-            return subscription.wrap(innerObservable.subscribe(atomicObserver));
+            return innerObservable.subscribe(atomicObserver);
         }
 
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationZip.java b/rxjava-core/src/main/java/rx/operators/OperationZip.java
deleted file mode 100644
index 7f6affae4f..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationZip.java
+++ /dev/null
@@ -1,446 +0,0 @@
-/**
- * Copyright 2014 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 java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-import rx.subscriptions.Subscriptions;
-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.Functions;
-
-/**
- * Returns an Observable that emits the results of a function applied to sets of items emitted, in
- * sequence, by two or more other Observables.
- * 
    
- * 
- * 
    
- * The zip operation 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 each zipped
- * Observable; the second item emitted by the new Observable will be the result of the function
- * applied to the second item emitted by each zipped Observable; and so forth.
- * 
    
- * The resulting Observable returned from zip will invoke onNext as many times as the
- * number of onNext invocations of the source Observable that emits the fewest items.
- */
-public final class OperationZip {
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, final Func2 zipFunction) {
-        return zip(Arrays.asList(o1, o2), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, final Func3 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, final Func4 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, final Func5 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6,
-            final Func6 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7,
-            final Func7 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
-            final Func8 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(zipFunction));
-    }
-
-    @SuppressWarnings("unchecked")
-    public static  OnSubscribeFunc zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
-            Observable o9, final Func9 zipFunction) {
-        return zip(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(zipFunction));
-    }
-
-    public static  OnSubscribeFunc zip(Iterable> ws, final FuncN zipFunction) {
-        return new ManyObservables(ws, zipFunction);
-    }
-
-    /**
-     * Merges the values across multiple sources and applies the selector
-     * function.
-     * 
    The resulting sequence terminates if no more pairs can be
-     * established, i.e., streams of length 1 and 2 zipped will produce
-     * only 1 item.
    
-     * 
    Exception semantics: errors from the source observable are
-     * propagated as-is.
    
-     * 
-     * @param 
-     *            the common element type
-     * @param 
-     *            the result element type
-     */
-    private static final class ManyObservables implements OnSubscribeFunc {
-        /** */
-        protected final Iterable> sources;
-        /** */
-        protected final FuncN selector;
-
-        /**
-         * Constructor.
-         * 
-         * @param sources
-         *            the sources
-         * @param selector
-         *            the result selector
-         */
-        public ManyObservables(
-                Iterable> sources,
-                FuncN selector) {
-            this.sources = sources;
-            this.selector = selector;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-
-            final CompositeSubscription composite = new CompositeSubscription();
-
-            final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
-
-            final List> all = new ArrayList>();
-
-            Observer> o2 = new Observer>() {
-                boolean done;
-                @Override
-                public void onCompleted() {
-                    if (!done) {
-                        done = true;
-                        observer.onCompleted();
-                    }
-                }
-
-                @Override
-                public void onError(Throwable t) {
-                    if (!done) {
-                        done = true;
-                        observer.onError(t);
-                    }
-                }
-
-                @Override
-                public void onNext(List value) {
-                    if (!done) {
-                        observer.onNext(selector.call(value.toArray(new Object[value.size()])));
-                    }
-                }
-            };
-
-            for (Observable o : sources) {
-
-                ItemObserver io = new ItemObserver(
-                        rwLock, all, o, o2, composite);
-                composite.add(io);
-                all.add(io);
-            }
-
-            for (ItemObserver io : all) {
-                io.connect();
-            }
-
-            return composite;
-        }
-
-        /**
-         * The individual line's observer.
-         * 
-         * @author akarnokd, 2013.01.14.
-         * @param 
-         *            the element type
-         */
-        private static final class ItemObserver implements Observer, Subscription {
-            /** Reader-writer lock. */
-            protected final ReadWriteLock rwLock;
-            /** The queue. */
-            public final Queue queue = new LinkedList();
-            /** The list of the other observers. */
-            public final List> all;
-            /** The global cancel. */
-            protected final Subscription cancel;
-            /** The subscription to the source. */
-            protected final SerialSubscription toSource = new SerialSubscription();
-            /** Indicate completion of this stream. */
-            protected boolean done;
-            /** The source. */
-            protected final Observable source;
-            /** The observer. */
-            protected final Observer> observer;
-
-            /**
-             * Constructor.
-             * 
-             * @param rwLock
-             *            the reader-writer lock to use
-             * @param all
-             *            all observers
-             * @param source
-             *            the source sequence
-             * @param observer
-             *            the output observer
-             * @param cancel
-             *            the cancellation handler
-             */
-            public ItemObserver(
-                    ReadWriteLock rwLock,
-                    List> all,
-                    Observable source,
-                    Observer> observer,
-                    Subscription cancel) {
-                this.rwLock = rwLock;
-                this.all = all;
-                this.source = source;
-                this.observer = observer;
-                this.cancel = cancel;
-            }
-
-            @Override
-            public void onNext(T value) {
-                rwLock.readLock().lock();
-                try {
-                    if (done) {
-                        return;
-                    }
-                    queue.add(value);
-                } finally {
-                    rwLock.readLock().unlock();
-                }
-                runCollector();
-            }
-
-            @Override
-            public void onError(Throwable ex) {
-                rwLock.writeLock().lock();
-                try {
-                    if (done) {
-                        return;
-                    }
-                    done = true;
-                    observer.onError(ex);
-                } finally {
-                    rwLock.writeLock().unlock();
-                }
-                cancel.unsubscribe();
-                unsubscribe();
-            }
-
-            @Override
-            public void onCompleted() {
-                rwLock.readLock().lock();
-                try {
-                    done = true;
-                } finally {
-                    rwLock.readLock().unlock();
-                }
-                runCollector();
-                unsubscribe();
-            }
-
-            /** Connect to the source observable. */
-            public void connect() {
-                toSource.set(source.subscribe(this));
-            }
-
-            @Override
-            public void unsubscribe() {
-                toSource.unsubscribe();
-            }
-            
-            @Override
-            public boolean isUnsubscribed() {
-                return toSource.isUnsubscribed();
-            }
-
-            private void runCollector() {
-                if (rwLock.writeLock().tryLock()) {
-                    boolean cu = false;
-                    try {
-                        while (true) {
-                            List values = new ArrayList(all.size());
-                            for (ItemObserver io : all) {
-                                if (io.queue.isEmpty()) {
-                                    if (io.done) {
-                                        observer.onCompleted();
-                                        cu = true;
-                                        return;
-                                    }
-                                } else {
-                                    T value = io.queue.peek();
-                                    values.add(value);
-                                }
-                            }
-                            if (values.size() == all.size()) {
-                                for (ItemObserver io : all) {
-                                    io.queue.poll();
-                                }
-                                observer.onNext(values);
-                            } else {
-                                break;
-                            }
-                        }
-                    } finally {
-                        rwLock.writeLock().unlock();
-                        if (cu) {
-                            cancel.unsubscribe();
-                        }
-                    }
-                }
-            }
-
-        }
-    }
-
-    /**
-     * Zips an Observable and an iterable sequence and applies
-     * a function to the pair of values.
-     */
-    public static  OnSubscribeFunc zipIterable(Observable source, Iterable other, Func2 zipFunction) {
-        return new ZipIterable(source, other, zipFunction);
-    }
-
-    /**
-     * Zips an Observable and an iterable sequence and applies
-     * a function to the pair of values.
-     */
-    private static final class ZipIterable implements OnSubscribeFunc {
-        final Observable source;
-        final Iterable other;
-        final Func2 zipFunction;
-
-        public ZipIterable(Observable source, Iterable other, Func2 zipFunction) {
-            this.source = source;
-            this.other = other;
-            this.zipFunction = zipFunction;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-
-            Iterator it;
-            boolean first;
-            try {
-                it = other.iterator();
-                first = it.hasNext();
-            } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
-            }
-
-            if (!first) {
-                t1.onCompleted();
-                return Subscriptions.empty();
-            }
-
-            SerialSubscription ssub = new SerialSubscription();
-
-            ssub.set(source.subscribe(new SourceObserver(t1, it, zipFunction, ssub)));
-
-            return ssub;
-        }
-
-        /** Observe the source. */
-        private static final class SourceObserver implements Observer {
-            final Observer observer;
-            final Iterator other;
-            final Func2 zipFunction;
-            final Subscription cancel;
-
-            public SourceObserver(Observer observer, Iterator other,
-                    Func2 zipFunction, Subscription cancel) {
-                this.observer = observer;
-                this.other = other;
-                this.zipFunction = zipFunction;
-                this.cancel = cancel;
-            }
-
-            @Override
-            public void onNext(T args) {
-                U u = other.next();
-
-                R r;
-                try {
-                    r = zipFunction.call(args, u);
-                } catch (Throwable t) {
-                    onError(t);
-                    return;
-                }
-
-                observer.onNext(r);
-
-                boolean has;
-                try {
-                    has = other.hasNext();
-                } catch (Throwable t) {
-                    onError(t);
-                    return;
-                }
-
-                if (!has) {
-                    onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-                cancel.unsubscribe();
-            }
-
-            @Override
-            public void onCompleted() {
-                observer.onCompleted();
-                cancel.unsubscribe();
-            }
-
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/util/Exceptions.java b/rxjava-core/src/main/java/rx/util/Exceptions.java
index 537af0872f..c59f36129b 100644
--- a/rxjava-core/src/main/java/rx/util/Exceptions.java
+++ b/rxjava-core/src/main/java/rx/util/Exceptions.java
@@ -38,4 +38,19 @@ public static RuntimeException propagate(Throwable t) {
         }
     }
 
+    public static void throwIfFatal(Throwable t) {
+        if (t instanceof OnErrorNotImplementedException) {
+            throw (OnErrorNotImplementedException) t;
+        }
+        // values here derived from https://github.com/Netflix/RxJava/issues/748#issuecomment-32471495
+        else if (t instanceof StackOverflowError) {
+            throw (StackOverflowError) t;
+        } else if (t instanceof VirtualMachineError) {
+            throw (VirtualMachineError) t;
+        } else if (t instanceof ThreadDeath) {
+            throw (ThreadDeath) t;
+        } else if (t instanceof LinkageError) {
+            throw (LinkageError) t;
+        }
+    }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
index b1bc776ce2..835d09a34d 100644
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
@@ -37,6 +37,7 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
+import rx.operators.SafeObserver;
 
 public class SynchronizedObserverTest {
 
@@ -54,8 +55,7 @@ public void testSingleThreadedBasic() {
         TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
-        SynchronizedObserver aw = new SynchronizedObserver(observer, as);
+        SynchronizedObserver aw = new SynchronizedObserver(observer);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -76,9 +76,8 @@ public void testMultiThreadedBasic() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -102,13 +101,12 @@ public void testMultiThreadedBasicWithLock() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
 
         Object lock = new Object();
         ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
 
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as, lock);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, lock);
 
         externalBusyThread.start();
 
@@ -142,9 +140,8 @@ public void testMultiThreadedWithNPE() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -174,13 +171,12 @@ public void testMultiThreadedWithNPEAndLock() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
 
         Object lock = new Object();
         ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
 
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as, lock);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, lock);
 
         externalBusyThread.start();
 
@@ -220,9 +216,8 @@ public void testMultiThreadedWithNPEinMiddle() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -250,13 +245,12 @@ public void testMultiThreadedWithNPEinMiddleAndLock() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
         Observable w = Observable.create(onSubscribe);
 
-        SafeObservableSubscription as = new SafeObservableSubscription(s);
         BusyObserver busyObserver = new BusyObserver();
 
         Object lock = new Object();
         ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
 
-        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, as, lock);
+        SynchronizedObserver aw = new SynchronizedObserver(busyObserver, lock);
 
         externalBusyThread.start();
 
@@ -300,8 +294,8 @@ public void runConcurrencyTest() {
         ExecutorService tp = Executors.newFixedThreadPool(20);
         try {
             TestConcurrencyObserver tw = new TestConcurrencyObserver();
-            SafeObservableSubscription s = new SafeObservableSubscription();
-            SynchronizedObserver w = new SynchronizedObserver(tw, s);
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            SynchronizedObserver w = new SynchronizedObserver(new SafeSubscriber(tw));
 
             Future f1 = tp.submit(new OnNextThread(w, 12000));
             Future f2 = tp.submit(new OnNextThread(w, 5000));
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
index 6a6908698a..60a05fd935 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
@@ -268,33 +268,6 @@ public void testMergeList() {
         verify(stringObserver, times(2)).onNext("hello");
     }
 
-    @Test
-    public void testUnSubscribe() {
-        TestObservable tA = new TestObservable();
-        TestObservable tB = new TestObservable();
-
-        @SuppressWarnings("unchecked")
-        Observable m = Observable.create(mergeDelayError(Observable.create(tA), Observable.create(tB)));
-        Subscription s = m.subscribe(stringObserver);
-
-        tA.sendOnNext("Aone");
-        tB.sendOnNext("Bone");
-        s.unsubscribe();
-        tA.sendOnNext("Atwo");
-        tB.sendOnNext("Btwo");
-        tA.sendOnCompleted();
-        tB.sendOnCompleted();
-
-        verify(stringObserver, never()).onError(any(Throwable.class));
-        verify(stringObserver, times(1)).onNext("Aone");
-        verify(stringObserver, times(1)).onNext("Bone");
-        assertTrue(tA.unsubscribed);
-        assertTrue(tB.unsubscribed);
-        verify(stringObserver, never()).onNext("Atwo");
-        verify(stringObserver, never()).onNext("Btwo");
-        verify(stringObserver, never()).onCompleted();
-    }
-
     @Test
     public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o1 = new TestASynchronousObservable();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index 652ff720ac..17296ac0d3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -28,7 +28,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscriber;
 import rx.schedulers.Schedulers;
+import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
@@ -246,6 +248,53 @@ public Integer call(Integer i) {
         }).toBlockingObservable().single();
     }
 
+    @Test(expected = RuntimeException.class)
+    public void verifyExceptionIsThrownIfThereIsNoExceptionHandler() {
+
+        Observable.OnSubscribe creator = new Observable.OnSubscribe() {
+
+            @Override
+            public void call(Subscriber observer) {
+                observer.onNext("a");
+                observer.onNext("b");
+                observer.onNext("c");
+                observer.onCompleted();
+            }
+        };
+
+        Func1> manyMapper = new Func1>() {
+
+            @Override
+            public Observable call(Object object) {
+
+                return Observable.from(object);
+            }
+        };
+
+        Func1 mapper = new Func1() {
+            private int count = 0;
+
+            @Override
+            public Object call(Object object) {
+                ++count;
+                if (count > 2) {
+                    throw new RuntimeException();
+                }
+                return object;
+            }
+        };
+
+        Action1 onNext = new Action1() {
+
+            @Override
+            public void call(Object object) {
+                System.out.println(object.toString());
+            }
+        };
+
+        Observable.create(creator).flatMap(manyMapper).map(mapper).subscribe(onNext);
+    }
+
     private static Map getMap(String prefix) {
         Map m = new HashMap();
         m.put("firstName", prefix + "First");
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
similarity index 64%
rename from rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java
rename to rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
index c94ba537ca..7f23a8379a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSynchronizeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
@@ -17,7 +17,6 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationSynchronize.*;
 
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -25,71 +24,10 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.observers.SafeSubscriber;
+import rx.observers.TestSubscriber;
 
-public class OperationSynchronizeTest {
-
-    /**
-     * Ensure onCompleted can not be called after an Unsubscribe
-     */
-    @Test
-    public void testOnCompletedAfterUnSubscribe() {
-        TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
-
-        @SuppressWarnings("unchecked")
-        Observer w = mock(Observer.class);
-        Subscription ws = st.subscribe(w);
-
-        System.out.println("ws: " + ws);
-        
-        t.sendOnNext("one");
-        ws.unsubscribe();
-        System.out.println("send onCompleted");
-        t.sendOnCompleted();
-
-        verify(w, times(1)).onNext("one");
-        verify(w, Mockito.never()).onCompleted();
-    }
-
-    /**
-     * Ensure onNext can not be called after an Unsubscribe
-     */
-    @Test
-    public void testOnNextAfterUnSubscribe() {
-        TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
-
-        @SuppressWarnings("unchecked")
-        Observer w = mock(Observer.class);
-        Subscription ws = st.subscribe(w);
-
-        t.sendOnNext("one");
-        ws.unsubscribe();
-        t.sendOnNext("two");
-
-        verify(w, times(1)).onNext("one");
-        verify(w, Mockito.never()).onNext("two");
-    }
-
-    /**
-     * Ensure onError can not be called after an Unsubscribe
-     */
-    @Test
-    public void testOnErrorAfterUnSubscribe() {
-        TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
-
-        @SuppressWarnings("unchecked")
-        Observer w = mock(Observer.class);
-        Subscription ws = st.subscribe(w);
-
-        t.sendOnNext("one");
-        ws.unsubscribe();
-        t.sendOnError(new RuntimeException("bad"));
-
-        verify(w, times(1)).onNext("one");
-        verify(w, Mockito.never()).onError(any(Throwable.class));
-    }
+public class SafeSubscriberTest {
 
     /**
      * Ensure onNext can not be called after onError
@@ -97,12 +35,12 @@ public void testOnErrorAfterUnSubscribe() {
     @Test
     public void testOnNextAfterOnError() {
         TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
+        Observable st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
         Observer w = mock(Observer.class);
         @SuppressWarnings("unused")
-        Subscription ws = st.subscribe(w);
+        Subscription ws = st.subscribe(new SafeSubscriber(new TestSubscriber(w)));
 
         t.sendOnNext("one");
         t.sendOnError(new RuntimeException("bad"));
@@ -119,12 +57,12 @@ public void testOnNextAfterOnError() {
     @Test
     public void testOnCompletedAfterOnError() {
         TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
+        Observable st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
         Observer w = mock(Observer.class);
         @SuppressWarnings("unused")
-        Subscription ws = st.subscribe(w);
+        Subscription ws = st.subscribe(new SafeSubscriber(new TestSubscriber(w)));
 
         t.sendOnNext("one");
         t.sendOnError(new RuntimeException("bad"));
@@ -141,12 +79,12 @@ public void testOnCompletedAfterOnError() {
     @Test
     public void testOnNextAfterOnCompleted() {
         TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
+        Observable st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
         Observer w = mock(Observer.class);
         @SuppressWarnings("unused")
-        Subscription ws = st.subscribe(w);
+        Subscription ws = st.subscribe(new SafeSubscriber(new TestSubscriber(w)));
 
         t.sendOnNext("one");
         t.sendOnCompleted();
@@ -164,12 +102,12 @@ public void testOnNextAfterOnCompleted() {
     @Test
     public void testOnErrorAfterOnCompleted() {
         TestObservable t = new TestObservable(null);
-        Observable st = Observable.create(synchronize(Observable.create(t)));
+        Observable st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
         Observer w = mock(Observer.class);
         @SuppressWarnings("unused")
-        Subscription ws = st.subscribe(w);
+        Subscription ws = st.subscribe(new SafeSubscriber(new TestSubscriber(w)));
 
         t.sendOnNext("one");
         t.sendOnCompleted();
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java
index c41e853733..ca42cba3d5 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservable.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java
@@ -100,7 +100,7 @@ public Notification call(Notification expectedNotfication, Notificati
                         message.append(" ").append(expectedNotfication.getValue());
                     if (expectedNotfication.hasThrowable())
                         message.append(" ").append(expectedNotfication.getThrowable());
-                    return new Notification("equals " + message.toString());
+                    return Notification.createOnNext("equals " + message.toString());
                 }
                 else {
                     StringBuilder error = new StringBuilder();
@@ -116,7 +116,7 @@ public Notification call(Notification expectedNotfication, Notificati
                         error.append(" ").append(actualNotification.getThrowable());
                     error.append(">");
 
-                    return new Notification(new AssertionError(error.toString()));
+                    return Notification.createOnError(new AssertionError(error.toString()));
                 }
             }
         };
@@ -131,9 +131,9 @@ public Notification call(Notification a, Notification b)
                 fail |= b.isOnError();
 
                 if (fail)
-                    return new Notification(new AssertionError(message));
+                    return Notification.createOnError(new AssertionError(message));
                 else
-                    return new Notification(message);
+                    return Notification.createOnNext(message);
             }
         };
 
@@ -142,9 +142,9 @@ public Notification call(Notification a, Notification b)
             public Notification call(Notification outcome) {
                 if (outcome.isOnError()) {
                     String fullMessage = (message != null ? message + ": " : "") + "Observables are different\n\t" + outcome.getThrowable().getMessage();
-                    return new Notification(new AssertionError(fullMessage));
+                    return Notification.createOnError(new AssertionError(fullMessage));
                 }
-                return new Notification();
+                return Notification.createOnCompleted();
             }
         }).dematerialize();
         return outcomeObservable;
diff --git a/rxjava-core/src/test/java/rx/util/ExceptionsTest.java b/rxjava-core/src/test/java/rx/util/ExceptionsTest.java
new file mode 100644
index 0000000000..8029038e0a
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/util/ExceptionsTest.java
@@ -0,0 +1,137 @@
+/**
+ * Copyright 2014 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.util;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.subjects.PublishSubject;
+import rx.util.functions.Action1;
+
+public class ExceptionsTest {
+
+    @Test(expected = OnErrorNotImplementedException.class)
+    public void testOnErrorNotImplementedIsThrown() {
+        Observable.from(1, 2, 3).subscribe(new Action1() {
+
+            @Override
+            public void call(Integer t1) {
+                throw new RuntimeException("hello");
+            }
+
+        });
+    }
+
+    @Test(expected = StackOverflowError.class)
+    public void testStackOverflowIsThrown() {
+        final PublishSubject a = PublishSubject.create();
+        final PublishSubject b = PublishSubject.create();
+        new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                e.printStackTrace();
+            }
+
+            @Override
+            public void onNext(Integer args) {
+                System.out.println(args);
+            }
+        };
+        a.subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                e.printStackTrace();
+            }
+
+            @Override
+            public void onNext(Integer args) {
+                System.out.println(args);
+            }
+        });
+        b.subscribe();
+        a.subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                e.printStackTrace();
+            }
+
+            @Override
+            public void onNext(Integer args) {
+                b.onNext(args + 1);
+            }
+        });
+        b.subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                e.printStackTrace();
+            }
+
+            @Override
+            public void onNext(Integer args) {
+                a.onNext(args + 1);
+            }
+        });
+        a.onNext(1);
+    }
+
+    @Test(expected = ThreadDeath.class)
+    public void testThreadDeathIsThrown() {
+        Observable.from(1).subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                e.printStackTrace();
+            }
+
+            @Override
+            public void onNext(Integer t) {
+                throw new ThreadDeath();
+            }
+
+        });
+    }
+
+}

From 9e2691729d94f00cde97efb0b39264c2f0c0b7f5 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 5 Feb 2014 10:04:29 +0100
Subject: [PATCH 338/441] ObserveOn Merge from @akarnokd:OperatorRepeat2

---
 rxjava-core/src/main/java/rx/Observable.java  |  12 +-
 .../java/rx/operators/OperationObserveOn.java | 129 ------------------
 .../java/rx/operators/OperatorObserveOn.java  |  67 +++++++++
 .../main/java/rx/operators/QueueDrain.java    | 106 ++++++++++++++
 ...OnTest.java => OperatorObserveOnTest.java} |   5 +-
 .../java/rx/operators/OperatorTakeTest.java   |  15 +-
 6 files changed, 195 insertions(+), 139 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/QueueDrain.java
 rename rxjava-core/src/test/java/rx/operators/{OperationObserveOnTest.java => OperatorObserveOnTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 3d672326e5..4723484c8f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -49,7 +49,6 @@
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
-import rx.operators.OperatorDoOnEach;
 import rx.operators.OperationElementAt;
 import rx.operators.OperationFilter;
 import rx.operators.OperationFinally;
@@ -63,13 +62,11 @@
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMinMax;
 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.OperationParallelMerge;
-import rx.operators.OperatorRepeat;
 import rx.operators.OperationReplay;
 import rx.operators.OperationRetry;
 import rx.operators.OperationSample;
@@ -96,18 +93,21 @@
 import rx.operators.OperationToObservableFuture;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
-import rx.operators.OperatorSubscribeOn;
-import rx.operators.OperatorZip;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorFromIterable;
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
+import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorParallel;
+import rx.operators.OperatorRepeat;
+import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimestamp;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
+import rx.operators.OperatorZip;
 import rx.operators.OperatorZipIterable;
 import rx.plugins.RxJavaObservableExecutionHook;
 import rx.plugins.RxJavaPlugins;
@@ -5151,7 +5151,7 @@ public final  ConnectableObservable multicast(SubjectRxJava Wiki: observeOn()
      */
     public final Observable observeOn(Scheduler scheduler) {
-        return create(OperationObserveOn.observeOn(this, scheduler));
+        return lift(new OperatorObserveOn(scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
deleted file mode 100644
index c3addd9933..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * Copyright 2014 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 java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicLong;
-
-import rx.Notification;
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.schedulers.ImmediateScheduler;
-import rx.schedulers.TrampolineScheduler;
-import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action1;
-
-/**
- * Asynchronously notify Observers on the specified Scheduler.
- * 
    
- * 
- */
-public class OperationObserveOn {
-
-    public static  OnSubscribeFunc observeOn(Observable source, Scheduler scheduler) {
-        return new ObserveOn(source, scheduler);
-    }
-
-    private static class ObserveOn implements OnSubscribeFunc {
-        private final Observable source;
-        private final Scheduler scheduler;
-
-        public ObserveOn(Observable source, Scheduler scheduler) {
-            this.source = source;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            if (scheduler instanceof ImmediateScheduler) {
-                // do nothing if we request ImmediateScheduler so we don't invoke overhead
-                return source.subscribe(observer);
-            } else if (scheduler instanceof TrampolineScheduler) {
-                // do nothing if we request CurrentThreadScheduler so we don't invoke overhead
-                return source.subscribe(observer);
-            } else {
-                return new Observation(observer).init();
-            }
-        }
-
-        /** Observe through individual queue per observer. */
-        private class Observation {
-            final Observer observer;
-            final CompositeSubscription compositeSubscription = new CompositeSubscription();
-            final ConcurrentLinkedQueue> queue = new ConcurrentLinkedQueue>();
-            final AtomicLong counter = new AtomicLong(0);
-            private volatile Scheduler.Inner recursiveScheduler;
-
-            public Observation(Observer observer) {
-                this.observer = observer;
-            }
-
-            public Subscription init() {
-                compositeSubscription.add(source.materialize().subscribe(new SourceObserver()));
-                return compositeSubscription;
-            }
-
-            private class SourceObserver implements Action1> {
-
-                @Override
-                public void call(Notification e) {
-                    queue.offer(e);
-                    if (counter.getAndIncrement() == 0) {
-                        if (recursiveScheduler == null) {
-                            // compositeSubscription for the outer scheduler, recursive for inner
-                            compositeSubscription.add(scheduler.schedule(new Action1() {
-
-                                @Override
-                                public void call(Inner inner) {
-                                    // record innerScheduler so 'processQueue' can use it for all subsequent executions
-                                    recursiveScheduler = inner;
-                                    // once we have the innerScheduler we can start doing real work
-                                    processQueue();
-                                }
-
-                            }));
-                        } else {
-                            processQueue();
-                        }
-                    }
-                }
-
-                void processQueue() {
-                    recursiveScheduler.schedule(new Action1() {
-                        @Override
-                        public void call(Inner inner) {
-                            Notification not = queue.poll();
-                            if (not != null) {
-                                not.accept(observer);
-                            }
-
-                            // decrement count and if we still have work to do
-                            // recursively schedule ourselves to process again
-                            if (counter.decrementAndGet() > 0) {
-                                inner.schedule(this);
-                            }
-                        }
-                    });
-                }
-            }
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
new file mode 100644
index 0000000000..bfbf52905b
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright 2014 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 rx.Notification;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.subscriptions.CompositeSubscription;
+import rx.util.functions.Action0;
+
+/**
+ * Move the observation of events to another thread via Scheduler.
+ * @param  the item type
+ */
+public class OperatorObserveOn implements Operator {
+    final Scheduler scheduler;
+    public OperatorObserveOn(Scheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber call(final Subscriber t1) {
+        final QueueDrain qd = new QueueDrain(t1);
+        final CompositeSubscription csub = new CompositeSubscription();
+        t1.add(csub);
+        return new Subscriber(t1) {
+            /** Dispatch the notification value. */
+            void run(final Notification nt) {
+                qd.enqueue(new Action0() {
+                    @Override
+                    public void call() {
+                        nt.accept(t1);
+                    }
+                });
+                qd.tryDrainAsync(scheduler, csub);
+            }
+            @Override
+            public void onNext(final T args) {
+                run(Notification.createOnNext(args));
+            }
+
+            @Override
+            public void onError(final Throwable e) {
+                run(Notification.createOnError(e));
+            }
+
+            @Override
+            public void onCompleted() {
+                run(Notification.createOnCompleted());
+            }
+        };
+    }
+    
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/QueueDrain.java b/rxjava-core/src/main/java/rx/operators/QueueDrain.java
new file mode 100644
index 0000000000..7e85c237e0
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/QueueDrain.java
@@ -0,0 +1,106 @@
+/**
+ * Copyright 2014 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 java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Action queue ensuring that only a single drain caller succeeds at a time.
+ * This class can be used to execute work without the issues of reentrancy and
+ * concurrency.
+ */
+public final class QueueDrain implements Runnable, Action0 {
+    /** The number of work items. */
+    private final AtomicInteger wip = new AtomicInteger();
+    /** The action queue. */
+    private final BlockingQueue queue = new LinkedBlockingQueue();
+    /** The subscription to stop the queue processing. */
+    private final Subscription k;
+    /**
+     * Constructor which takes a cancellation token.
+     * @param k the cancellation token (aka subscription).
+     */
+    public QueueDrain(Subscription k) {
+        this.k = k;
+    }
+    /**
+     * Enqueue an action.
+     * To execute any queued action, call {@link #tryDrain()} or
+     * submit this instance to a {@code Scheduler.schedule()} method.
+     * @param action the action to enqueue, not null
+     */
+    public void enqueue(Action0 action) {
+        if (!k.isUnsubscribed()) {
+            queue.add(action);
+        }
+    }
+    /**
+     * Try draining the queue and executing the actions in it.
+     */
+    public void tryDrain() {
+        if (wip.incrementAndGet() > 1 || k.isUnsubscribed()) {
+            return;
+        }
+        do {
+            queue.poll().call();
+        } while (wip.decrementAndGet() > 0 && !k.isUnsubscribed());
+    }
+    /**
+     * Try draining the queue on the given scheduler.
+     * The method ensures that only one thread is actively draining the
+     * queue on the given scheduler.
+     * @param scheduler the scheduler where the draining should happen
+     * @param cs the composite subscription to track the schedule
+     */
+    public void tryDrainAsync(Scheduler scheduler, final CompositeSubscription cs) {
+        if (cs.isUnsubscribed() || wip.incrementAndGet() > 1) {
+            return;
+        }
+        // add tracking subscription only if schedule is run to avoid overfilling cs
+        final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+        cs.add(mas);
+        mas.set(scheduler.schedule(new Action1() {
+            @Override
+            public void call(Scheduler.Inner o) {
+                if (!cs.isUnsubscribed()) {
+                    do {
+                        queue.poll().call();
+                    } while (wip.decrementAndGet() > 0 && !cs.isUnsubscribed());
+                }
+                cs.remove(mas);
+            }
+        }));
+    }
+    @Override
+    public void run() {
+        // to help the draining of the queue on a ThreadPool/Scheduler
+        tryDrain();
+    }
+
+    @Override
+    public void call() {
+        tryDrain();
+    }
+    
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 0e3a892599..f180658722 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -18,7 +18,6 @@
 import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationObserveOn.*;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -37,7 +36,7 @@
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 
-public class OperationObserveOnTest {
+public class OperatorObserveOnTest {
 
     /**
      * This is testing a no-op path since it uses Schedulers.immediate() which will not do scheduling.
@@ -46,7 +45,7 @@ public class OperationObserveOnTest {
     @SuppressWarnings("unchecked")
     public void testObserveOn() {
         Observer observer = mock(Observer.class);
-        Observable.create(observeOn(Observable.from(1, 2, 3), Schedulers.immediate())).subscribe(observer);
+        Observable.from(1, 2, 3).observeOn(Schedulers.immediate()).subscribe(observer);
 
         verify(observer, times(1)).onNext(1);
         verify(observer, times(1)).onNext(2);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 9eb07b20ef..02e832d5d8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -16,7 +16,6 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
@@ -32,6 +31,7 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
@@ -288,4 +288,17 @@ public void call(Subscriber op) {
         }
 
     });
+    
+    @Test(timeout = 2000)
+    public void testTakeObserveOn() {
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        
+        INFINITE_OBSERVABLE.observeOn(Schedulers.newThread()).take(1).subscribe(o);
+        
+        verify(o).onNext(1L);
+        verify(o, never()).onNext(2L);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
 }

From 446acf5cd8b533dfd4fd26848c9f33aedf0ad95e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 21:53:04 -0800
Subject: [PATCH 339/441] ObserveOn with Backpressure

---
 .../java/rx/operators/OperatorObserveOn.java  | 165 ++++++++++++++----
 .../main/java/rx/operators/QueueDrain.java    | 106 -----------
 .../java/rx/schedulers/TestScheduler.java     |  12 +-
 .../rx/operators/OperatorObserveOnTest.java   |   6 +-
 4 files changed, 143 insertions(+), 146 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/QueueDrain.java

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index bfbf52905b..418d795634 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,53 +15,156 @@
  */
 package rx.operators;
 
-import rx.Notification;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.atomic.AtomicLong;
+
 import rx.Scheduler;
+import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action0;
+import rx.schedulers.ImmediateScheduler;
+import rx.schedulers.TestScheduler;
+import rx.schedulers.TrampolineScheduler;
+import rx.util.functions.Action1;
 
 /**
- * Move the observation of events to another thread via Scheduler.
- * @param  the item type
+ * Asynchronously notify Observers on the specified Scheduler.
+ * 
    
+ * 
  */
 public class OperatorObserveOn implements Operator {
-    final Scheduler scheduler;
+
+    private final Scheduler scheduler;
+
     public OperatorObserveOn(Scheduler scheduler) {
         this.scheduler = scheduler;
     }
 
     @Override
-    public Subscriber call(final Subscriber t1) {
-        final QueueDrain qd = new QueueDrain(t1);
-        final CompositeSubscription csub = new CompositeSubscription();
-        t1.add(csub);
-        return new Subscriber(t1) {
-            /** Dispatch the notification value. */
-            void run(final Notification nt) {
-                qd.enqueue(new Action0() {
-                    @Override
-                    public void call() {
-                        nt.accept(t1);
-                    }
-                });
-                qd.tryDrainAsync(scheduler, csub);
+    public Subscriber call(Subscriber child) {
+        if (scheduler instanceof ImmediateScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else if (scheduler instanceof TrampolineScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else if (scheduler instanceof TestScheduler) {
+            // this one will deadlock as it is single-threaded and won't run the scheduled
+            // work until it manually advances, which it won't be able to do as it will block
+            return child;
+        } else {
+            return new ObserveOnSubscriber(child);
+        }
+
+    }
+
+    private static Object NULL_SENTINEL = new Object();
+    private static Object COMPLETE_SENTINEL = new Object();
+
+    private static class ErrorSentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
+
+    /** Observe through individual queue per observer. */
+    private class ObserveOnSubscriber extends Subscriber {
+        final Subscriber observer;
+        private volatile Scheduler.Inner recursiveScheduler;
+
+        private final ArrayBlockingQueue queue = new ArrayBlockingQueue(1);
+        final AtomicLong counter = new AtomicLong(0);
+
+        public ObserveOnSubscriber(Subscriber observer) {
+            super(observer);
+            this.observer = observer;
+        }
+
+        @Override
+        public void onNext(final T t) {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                if (t == null) {
+                    queue.put(NULL_SENTINEL);
+                } else {
+                    queue.put(t);
+                }
+                schedule();
+            } catch (InterruptedException e) {
+                onError(e);
             }
-            @Override
-            public void onNext(final T args) {
-                run(Notification.createOnNext(args));
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                queue.put(COMPLETE_SENTINEL);
+                schedule();
+            } catch (InterruptedException e) {
+                onError(e);
             }
+        }
 
-            @Override
-            public void onError(final Throwable e) {
-                run(Notification.createOnError(e));
+        @Override
+        public void onError(final Throwable e) {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                queue.put(new ErrorSentinel(e));
+                schedule();
+            } catch (InterruptedException e2) {
+                // call directly if we can't schedule
+                observer.onError(e2);
             }
+        }
+
+        protected void schedule() {
+            if (counter.getAndIncrement() == 0) {
+                if (recursiveScheduler == null) {
+                    add(scheduler.schedule(new Action1() {
+
+                        @Override
+                        public void call(Inner inner) {
+                            recursiveScheduler = inner;
+                            pollQueue();
+                        }
+
+                    }));
+                } else {
+                    recursiveScheduler.schedule(new Action1() {
 
-            @Override
-            public void onCompleted() {
-                run(Notification.createOnCompleted());
+                        @Override
+                        public void call(Inner inner) {
+                            pollQueue();
+                        }
+
+                    });
+                }
             }
-        };
+        }
+
+        @SuppressWarnings("unchecked")
+        private void pollQueue() {
+            do {
+                Object v = queue.poll();
+                if (v != null) {
+                    if (v == NULL_SENTINEL) {
+                        observer.onNext(null);
+                    } else if (v == COMPLETE_SENTINEL) {
+                        observer.onCompleted();
+                    } else if (v instanceof ErrorSentinel) {
+                        observer.onError(((ErrorSentinel) v).e);
+                    } else {
+                        observer.onNext((T) v);
+                    }
+                }
+            } while (counter.decrementAndGet() > 0);
+        }
+
     }
-    
+
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/QueueDrain.java b/rxjava-core/src/main/java/rx/operators/QueueDrain.java
deleted file mode 100644
index 7e85c237e0..0000000000
--- a/rxjava-core/src/main/java/rx/operators/QueueDrain.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/**
- * Copyright 2014 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 java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicInteger;
-import rx.Scheduler;
-import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.MultipleAssignmentSubscription;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-
-/**
- * Action queue ensuring that only a single drain caller succeeds at a time.
- * This class can be used to execute work without the issues of reentrancy and
- * concurrency.
- */
-public final class QueueDrain implements Runnable, Action0 {
-    /** The number of work items. */
-    private final AtomicInteger wip = new AtomicInteger();
-    /** The action queue. */
-    private final BlockingQueue queue = new LinkedBlockingQueue();
-    /** The subscription to stop the queue processing. */
-    private final Subscription k;
-    /**
-     * Constructor which takes a cancellation token.
-     * @param k the cancellation token (aka subscription).
-     */
-    public QueueDrain(Subscription k) {
-        this.k = k;
-    }
-    /**
-     * Enqueue an action.
-     * To execute any queued action, call {@link #tryDrain()} or
-     * submit this instance to a {@code Scheduler.schedule()} method.
-     * @param action the action to enqueue, not null
-     */
-    public void enqueue(Action0 action) {
-        if (!k.isUnsubscribed()) {
-            queue.add(action);
-        }
-    }
-    /**
-     * Try draining the queue and executing the actions in it.
-     */
-    public void tryDrain() {
-        if (wip.incrementAndGet() > 1 || k.isUnsubscribed()) {
-            return;
-        }
-        do {
-            queue.poll().call();
-        } while (wip.decrementAndGet() > 0 && !k.isUnsubscribed());
-    }
-    /**
-     * Try draining the queue on the given scheduler.
-     * The method ensures that only one thread is actively draining the
-     * queue on the given scheduler.
-     * @param scheduler the scheduler where the draining should happen
-     * @param cs the composite subscription to track the schedule
-     */
-    public void tryDrainAsync(Scheduler scheduler, final CompositeSubscription cs) {
-        if (cs.isUnsubscribed() || wip.incrementAndGet() > 1) {
-            return;
-        }
-        // add tracking subscription only if schedule is run to avoid overfilling cs
-        final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-        cs.add(mas);
-        mas.set(scheduler.schedule(new Action1() {
-            @Override
-            public void call(Scheduler.Inner o) {
-                if (!cs.isUnsubscribed()) {
-                    do {
-                        queue.poll().call();
-                    } while (wip.decrementAndGet() > 0 && !cs.isUnsubscribed());
-                }
-                cs.remove(mas);
-            }
-        }));
-    }
-    @Override
-    public void run() {
-        // to help the draining of the queue on a ThreadPool/Scheduler
-        tryDrain();
-    }
-
-    @Override
-    public void call() {
-        tryDrain();
-    }
-    
-}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index 2c10fa4efb..a858a93ccb 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -19,24 +19,22 @@
 import java.util.PriorityQueue;
 import java.util.Queue;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Scheduler;
 import rx.Subscription;
 import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
-import rx.util.functions.Func2;
 
 public class TestScheduler extends Scheduler {
     private final Queue queue = new PriorityQueue(11, new CompareActionsByTime());
+    private static long counter = 0;
 
     private static class TimedAction {
 
         private final long time;
         private final Action1 action;
         private final Inner scheduler;
+        private final long count = counter++; // for differentiating tasks at same time
 
         private TimedAction(Inner scheduler, long time, Action1 action) {
             this.time = time;
@@ -53,7 +51,11 @@ public String toString() {
     private static class CompareActionsByTime implements Comparator {
         @Override
         public int compare(TimedAction action1, TimedAction action2) {
-            return Long.valueOf(action1.time).compareTo(Long.valueOf(action2.time));
+            if (action1.time == action2.time) {
+                return Long.valueOf(action1.count).compareTo(Long.valueOf(action2.count));
+            } else {
+                return Long.valueOf(action1.time).compareTo(Long.valueOf(action2.time));
+            }
         }
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index f180658722..4c975ba6db 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -30,6 +30,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Scheduler;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 import rx.util.functions.Action0;
@@ -141,7 +142,7 @@ public void call() {
 
     @Test
     public void observeOnTheSameSchedulerTwice() {
-        TestScheduler scheduler = new TestScheduler();
+        Scheduler scheduler = Schedulers.immediate();
 
         Observable o = Observable.from(1, 2, 3);
         Observable o2 = o.observeOn(scheduler);
@@ -157,8 +158,6 @@ public void observeOnTheSameSchedulerTwice() {
         o2.subscribe(observer1);
         o2.subscribe(observer2);
 
-        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-
         inOrder1.verify(observer1, times(1)).onNext(1);
         inOrder1.verify(observer1, times(1)).onNext(2);
         inOrder1.verify(observer1, times(1)).onNext(3);
@@ -172,7 +171,6 @@ public void observeOnTheSameSchedulerTwice() {
         inOrder2.verify(observer2, times(1)).onCompleted();
         verify(observer2, never()).onError(any(Throwable.class));
         inOrder2.verifyNoMoreInteractions();
-
     }
 
     @Test

From ac83ed9b44d2e1ad7f066bd794b4c676c5a86adf Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:06:01 -0800
Subject: [PATCH 340/441] Make Parallel use NewThread until Computation Fixed

See https://github.com/Netflix/RxJava/issues/713
It was causing non-deterministic behavior, random test failures and poor performance.
---
 rxjava-core/src/main/java/rx/Observable.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4723484c8f..e6a3dd4921 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5296,7 +5296,9 @@ public final Observable onExceptionResumeNext(final Observable r
      * @see RxJava Wiki: parallel()
      */
     public final  Observable parallel(Func1, Observable> f) {
-        return lift(new OperatorParallel(f, Schedulers.computation()));
+        // TODO move this back to Schedulers.computation() again once that is properly using eventloops
+        // see https://github.com/Netflix/RxJava/issues/713 for why this was changed
+        return lift(new OperatorParallel(f, Schedulers.newThread()));
     }
 
     /**

From df7bf90803a686946e09d9ec175f8ab85277e989 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:08:17 -0800
Subject: [PATCH 341/441] GroupBy Test Improvement

ObserveOn was the wrong mechanism for delaying behavior as it was relying on the buffering of observeOn.
Now using delay() to delay the group since observeOn no longer buffers.
---
 .../src/test/java/rx/operators/OperatorGroupByTest.java  | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index c808e396bb..92b085ea0f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -484,21 +484,16 @@ public Integer call(Integer i) {
                     @Override
                     public Observable call(GroupedObservable group) {
                         if (group.getKey() == 0) {
-                            return group.observeOn(Schedulers.newThread()).map(new Func1() {
+                            return group.delay(100, TimeUnit.MILLISECONDS).map(new Func1() {
 
                                 @Override
                                 public Integer call(Integer t) {
-                                    try {
-                                        Thread.sleep(2);
-                                    } catch (InterruptedException e) {
-                                        e.printStackTrace();
-                                    }
                                     return t * 10;
                                 }
 
                             });
                         } else {
-                            return group.observeOn(Schedulers.newThread());
+                            return group;
                         }
                     }
                 })

From eea02d87634d77afa4a417f4dd0bae84baacdf77 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:09:08 -0800
Subject: [PATCH 342/441] Fast Producer / Slow Consumer Backpressure Tests for
 ObserveOn

---
 .../main/java/rx/schedulers/Schedulers.java   |  4 +
 .../rx/operators/OperatorObserveOnTest.java   | 97 +++++++++++++++++++
 .../rx/schedulers/AbstractSchedulerTests.java | 67 -------------
 3 files changed, 101 insertions(+), 67 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index d9ad39aabb..bb0a75e358 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -183,4 +183,8 @@ public Thread newThread(Runnable r) {
 
         return result;
     }
+
+    public static TestScheduler test() {
+        return new TestScheduler();
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 4c975ba6db..21906ccc30 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -29,10 +29,15 @@
 import org.mockito.stubbing.Answer;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscription;
+import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
+import rx.schedulers.TrampolineScheduler;
+import rx.subscriptions.BooleanSubscription;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
@@ -305,6 +310,98 @@ public void call(Integer t1) {
                 });
     }
 
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThread() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread());
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeIO() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.io());
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTrampoline() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.trampoline());
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTestScheduler() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.test());
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeComputation() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.computation());
+    }
+
+    private final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Scheduler scheduler) throws InterruptedException {
+        final AtomicInteger countEmitted = new AtomicInteger();
+        final AtomicInteger countTaken = new AtomicInteger();
+        int value = Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer o) {
+                final BooleanSubscription s = BooleanSubscription.create();
+                Thread t = new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        int i = 1;
+                        while (!s.isUnsubscribed() && i <= 100) {
+                            System.out.println("onNext from fast producer [" + Thread.currentThread() + "]: " + i);
+                            o.onNext(i++);
+                        }
+                        o.onCompleted();
+                    }
+                });
+                t.setDaemon(true);
+                t.start();
+                return s;
+            }
+        }).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                countEmitted.incrementAndGet();
+            }
+        }).doOnCompleted(new Action0() {
+
+            @Override
+            public void call() {
+                System.out.println("-------- Done Emitting from Source ---------");
+            }
+        }).observeOn(scheduler).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                System.out.println(">> onNext to slowConsumer  [" + Thread.currentThread() + "] pre-take: " + i);
+                //force it to be slower than the producer
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                countTaken.incrementAndGet();
+            }
+        }).take(10).toBlockingObservable().last();
+
+        if (scheduler instanceof TrampolineScheduler || scheduler instanceof ImmediateScheduler || scheduler instanceof TestScheduler) {
+            // since there is no concurrency it will block and only emit as many as it can process
+            assertEquals(10, countEmitted.get());
+        } else {
+            // the others with concurrency should not emit all 100 ... but 10 + 2 in the pipeline
+            // NOTE: The +2 could change if the implementation of the queue logic changes. See Javadoc at top of class.
+            assertEquals(12, countEmitted.get());
+        }
+        // number received after take (but take will filter any extra)
+        assertEquals(10, value);
+        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        // we expect only 10 to make it through the observeOn side
+        assertEquals(10, countTaken.get());
+    }
+
     private static int randomIntFrom0to100() {
         // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
         long x = System.nanoTime();
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index bfea193310..046710bfaf 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -55,73 +55,6 @@ public abstract class AbstractSchedulerTests {
      */
     protected abstract Scheduler getScheduler();
 
-    @Test
-    public final void unsubscribeWithFastProducerWithSlowConsumerCausingQueuing() throws InterruptedException {
-        final AtomicInteger countEmitted = new AtomicInteger();
-        final AtomicInteger countTaken = new AtomicInteger();
-        int value = Observable.create(new OnSubscribeFunc() {
-
-            @Override
-            public Subscription onSubscribe(final Observer o) {
-                final BooleanSubscription s = BooleanSubscription.create();
-                Thread t = new Thread(new Runnable() {
-
-                    @Override
-                    public void run() {
-                        int i = 1;
-                        while (!s.isUnsubscribed() && i <= 100) {
-                            System.out.println("onNext from fast producer: " + i);
-                            o.onNext(i++);
-                        }
-                        o.onCompleted();
-                    }
-                });
-                t.setDaemon(true);
-                t.start();
-                return s;
-            }
-        }).doOnNext(new Action1() {
-
-            @Override
-            public void call(Integer i) {
-                countEmitted.incrementAndGet();
-            }
-        }).doOnCompleted(new Action0() {
-
-            @Override
-            public void call() {
-                System.out.println("-------- Done Emitting from Source ---------");
-            }
-        }).observeOn(getScheduler()).doOnNext(new Action1() {
-
-            @Override
-            public void call(Integer i) {
-                System.out.println(">> onNext to slowConsumer pre-take: " + i);
-                //force it to be slower than the producer
-                try {
-                    Thread.sleep(10);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                countTaken.incrementAndGet();
-            }
-        }).take(10).toBlockingObservable().last();
-
-        if (getScheduler() instanceof TrampolineScheduler || getScheduler() instanceof ImmediateScheduler) {
-            // since there is no concurrency it will block and only emit as many as it can process
-            assertEquals(10, countEmitted.get());
-        } else {
-            // they will all emit because the consumer is running slow
-            assertEquals(100, countEmitted.get());
-        }
-        // number received after take (but take will filter any extra)
-        assertEquals(10, value);
-        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
-        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        // we expect only 10 to make it through the observeOn side
-        assertEquals(10, countTaken.get());
-    }
-
     @Test
     public void testNestedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();

From c758d1370419141528903380d8689368e1c68630 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:10:30 -0800
Subject: [PATCH 343/441] Custom InterruptibleBlockingQueue for ObserveOn

Since we are blocking the producer on* notifications we need to interrupt it on unsubscribe events.
I need to do it on the data structure and not the thread as the thread could change for each onNext and that could have unexpected consequences.
---
 .../java/rx/operators/OperatorObserveOn.java  | 89 ++++++++++++++++++-
 1 file changed, 85 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 418d795634..b2e10593b5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
@@ -24,11 +24,25 @@
 import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
- * Asynchronously notify Observers on the specified Scheduler.
+ * Delivers events on the specified Scheduler.
  * 
    
+ * This provides backpressure by blocking the incoming onNext when there is already one in the queue.
+ * 
    
+ * This means that at any given time the max number of "onNext" in flight is 3:
+ * -> 1 being delivered on the Scheduler
+ * -> 1 in the queue waiting for the Scheduler
+ * -> 1 blocking on the queue waiting to deliver it
+ * 
+ * I have chosen to allow 1 in the queue rather than using an Exchanger style process so that the Scheduler
+ * can loop and have something to do each time around to optimize for avoiding rescheduling when it
+ * can instead just loop. I'm avoiding having the Scheduler thread ever block as it could be an event-loop
+ * thus if the queue is empty it exits and next time something is added it will reschedule.
+ * 
  * 
  */
 public class OperatorObserveOn implements Operator {
@@ -73,7 +87,7 @@ private class ObserveOnSubscriber extends Subscriber {
         final Subscriber observer;
         private volatile Scheduler.Inner recursiveScheduler;
 
-        private final ArrayBlockingQueue queue = new ArrayBlockingQueue(1);
+        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue();
         final AtomicLong counter = new AtomicLong(0);
 
         public ObserveOnSubscriber(Subscriber observer) {
@@ -93,7 +107,9 @@ public void onNext(final T t) {
                 }
                 schedule();
             } catch (InterruptedException e) {
-                onError(e);
+                if (!isUnsubscribed()) {
+                    onError(e);
+                }
             }
         }
 
@@ -125,6 +141,18 @@ public void onError(final Throwable e) {
         protected void schedule() {
             if (counter.getAndIncrement() == 0) {
                 if (recursiveScheduler == null) {
+                    // first time through, register a Subscription
+                    // that can interrupt this thread
+                    add(Subscriptions.create(new Action0() {
+
+                        @Override
+                        public void call() {
+                            // we have to interrupt the parent thread because
+                            // it can be blocked on queue.put
+                            queue.interrupt();
+                        }
+
+                    }));
                     add(scheduler.schedule(new Action1() {
 
                         @Override
@@ -167,4 +195,57 @@ private void pollQueue() {
 
     }
 
+    /**
+     * Same behavior as ArrayBlockingQueue(1) except that we can interrupt/unsubscribe it.
+     */
+    private class InterruptibleBlockingQueue {
+
+        private final Semaphore semaphore = new Semaphore(1);
+        private volatile Object item;
+        private volatile boolean interrupted = false;
+
+        public Object poll() {
+            if (interrupted) {
+                return null;
+            }
+            if (item == null) {
+                return null;
+            }
+            try {
+                return item;
+            } finally {
+                item = null;
+                semaphore.release();
+            }
+        }
+
+        /**
+         * Add an Object, blocking if an item is already in the queue.
+         * 
+         * @param o
+         * @throws InterruptedException
+         */
+        public void put(Object o) throws InterruptedException {
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            semaphore.acquire();
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            if (o == null) {
+                throw new IllegalArgumentException("Can not put null");
+            }
+            item = o;
+        }
+
+        /**
+         * Used to unsubscribe and interrupt the producer if blocked in put()
+         */
+        public void interrupt() {
+            interrupted = true;
+            semaphore.release();
+        }
+    }
+
 }
\ No newline at end of file

From 974b4ad3c9621c94efa6c9702e59613dd1dbb5a7 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:11:17 -0800
Subject: [PATCH 344/441] Changed to use SubscribeOn instead of ObserveOn for
 Async Behavior

The ObserveOn operator is for moving where it executes, not making it async. SubscribeOn makes it async.
---
 .../test/java/rx/subjects/ReplaySubjectTest.java   | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 14a6bbb039..3a360300f5 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -311,7 +311,8 @@ public void onNext(String v) {
         subject.onNext("two");
         assertEquals("two", lastValueForObserver1.get());
 
-        Subscription s2 = subject.observeOn(Schedulers.newThread()).subscribe(observer2);
+        // use subscribeOn to make this async otherwise we deadlock as we are using CountDownLatches
+        Subscription s2 = subject.subscribeOn(Schedulers.newThread()).subscribe(observer2);
 
         System.out.println("before waiting for one");
 
@@ -321,12 +322,23 @@ public void onNext(String v) {
         System.out.println("after waiting for one");
 
         subject.onNext("three");
+        
+        System.out.println("sent three");
+        
         // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet 
         assertEquals("three", lastValueForObserver1.get());
+        
+        System.out.println("about to send onCompleted");
+        
         subject.onCompleted();
 
+        System.out.println("completed subject");
+        
         // release 
         makeSlow.countDown();
+        
+        System.out.println("makeSlow released");
+        
         completed.await();
         // all of them should be emitted with the last being "three"
         assertEquals("three", lastValueForObserver2.get());

From 10e8b78a089c062fc6b67692641b08d7c8d2e8db Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 6 Feb 2014 23:18:42 -0800
Subject: [PATCH 345/441] Test to prove non-blocking despite blocking onNext

---
 .../rx/operators/OperatorObserveOnTest.java   | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 21906ccc30..5afa2729d6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -22,6 +22,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -310,6 +311,41 @@ public void call(Integer t1) {
                 });
     }
 
+    @Test
+    public void testNonBlockingOuterWhileBlockingOnNext() throws InterruptedException {
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicLong completeTime = new AtomicLong();
+        // use subscribeOn to make async, observeOn to move
+        Observable.range(1, 1000).subscribeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+                System.out.println("onCompleted");
+                completeTime.set(System.nanoTime());
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(Integer t) {
+
+            }
+
+        });
+
+        long afterSubscribeTime = System.nanoTime();
+        System.out.println("After subscribe: " + latch.getCount());
+        assertEquals(1, latch.getCount());
+        latch.await();
+        assertTrue(completeTime.get() > afterSubscribeTime);
+        System.out.println("onComplete nanos after subscribe: " + (completeTime.get() - afterSubscribeTime));
+    }
+
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThread() throws InterruptedException {
         testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread());

From e657d22cff7c2d2c2ae00ed38ee25d5a93b8995f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 14:33:00 -0800
Subject: [PATCH 346/441] Performance Testing

---
 .../java/rx/ObservableCreatePerformance.java  |  4 ++
 .../OperatorFromIterablePerformance.java      |  4 ++
 .../rx/operators/OperatorMapPerformance.java  |  4 ++
 .../operators/OperatorMergePerformance.java   |  4 ++
 .../OperatorObserveOnPerformance.java         | 46 +++++++++++++++++++
 .../rx/operators/OperatorTakePerformance.java |  4 ++
 .../rx/operators/OperatorZipPerformance.java  |  5 +-
 .../rx/perf/AbstractPerformanceTester.java    | 20 +++++---
 .../CompositeSubscriptionAddRemovePerf.java   |  5 ++
 9 files changed, 88 insertions(+), 8 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java

diff --git a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java b/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
index f55dd998bd..6e892a324b 100644
--- a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
+++ b/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
@@ -7,6 +7,10 @@
 
 public class ObservableCreatePerformance extends AbstractPerformanceTester {
 
+    ObservableCreatePerformance() {
+        super(REPETITIONS);
+    }
+
     public static void main(String args[]) {
 
         final ObservableCreatePerformance spt = new ObservableCreatePerformance();
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
index acb41eb576..ea3f2c18c3 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
@@ -11,6 +11,10 @@
 
 public class OperatorFromIterablePerformance extends AbstractPerformanceTester {
 
+    OperatorFromIterablePerformance() {
+        super(REPETITIONS);
+    }
+    
     public static void main(String args[]) {
 
         final OperatorFromIterablePerformance spt = new OperatorFromIterablePerformance();
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
index 2f73af1d0e..dc85a1d6e6 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
@@ -8,6 +8,10 @@
 
 public class OperatorMapPerformance extends AbstractPerformanceTester {
 
+    OperatorMapPerformance() {
+        super(REPETITIONS);
+    }
+    
     public static void main(String args[]) {
 
         final OperatorMapPerformance spt = new OperatorMapPerformance();
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
index de4b204ff1..99ce4deac9 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
@@ -9,6 +9,10 @@
 
 public class OperatorMergePerformance extends AbstractPerformanceTester {
 
+    OperatorMergePerformance() {
+        super(REPETITIONS);
+    }
+    
     public static void main(String args[]) {
 
         final OperatorMergePerformance spt = new OperatorMergePerformance();
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
new file mode 100644
index 0000000000..c25857ea54
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
@@ -0,0 +1,46 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+import rx.schedulers.Schedulers;
+import rx.util.functions.Action0;
+
+public class OperatorObserveOnPerformance extends AbstractPerformanceTester {
+
+    private static long reps = 1000000;
+
+    OperatorObserveOnPerformance() {
+        super(reps);
+    }
+
+    public static void main(String args[]) {
+
+        final OperatorObserveOnPerformance spt = new OperatorObserveOnPerformance();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.timeObserveOn();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * Observable.from(1L).observeOn()
+     * 
+     */
+    public long timeObserveOn() {
+
+        Observable s = Observable.range(1, (int) reps).observeOn(Schedulers.newThread());
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        return o.sum;
+    }
+
+}
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
index b64b3c9de1..3e8e8be702 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
@@ -7,6 +7,10 @@
 
 public class OperatorTakePerformance extends AbstractPerformanceTester {
 
+    OperatorTakePerformance() {
+        super(REPETITIONS);
+    }
+    
     public static void main(String args[]) {
 
         final OperatorTakePerformance spt = new OperatorTakePerformance();
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
index 2f22b81303..0d929b6a33 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
@@ -3,12 +3,15 @@
 import rx.Observable;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
-import rx.perf.LongSumObserver;
 import rx.util.functions.Action0;
 import rx.util.functions.Func2;
 
 public class OperatorZipPerformance extends AbstractPerformanceTester {
 
+    OperatorZipPerformance() {
+        super(REPETITIONS);
+    }
+    
     public static void main(String args[]) {
 
         final OperatorZipPerformance spt = new OperatorZipPerformance();
diff --git a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java b/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
index 56d92278ab..468f900f88 100644
--- a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
+++ b/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
@@ -6,9 +6,15 @@
 
 public abstract class AbstractPerformanceTester {
 
-    public static final int REPETITIONS = 5 * 1000 * 1000;
+    public static final long REPETITIONS = 5 * 1000 * 1000;
     public static final int NUM_PRODUCERS = 1;
 
+    private final long repetitions;
+
+    protected AbstractPerformanceTester(long repetitions) {
+        this.repetitions = repetitions;
+    }
+
     public final void runTest(Action0 action) throws InterruptedException {
         for (int runNum = 0; runNum < 15; runNum++) {
             System.gc();
@@ -19,7 +25,7 @@ public final void runTest(Action0 action) throws InterruptedException {
             action.call();
 
             long duration = System.nanoTime() - start;
-            long opsPerSec = (REPETITIONS * NUM_PRODUCERS * 1000L * 1000L * 1000L) / duration;
+            long opsPerSec = (repetitions * NUM_PRODUCERS * 1000L * 1000L * 1000L) / duration;
             System.out.printf("Run: %d - %,d ops/sec \n",
                     Integer.valueOf(runNum),
                     Long.valueOf(opsPerSec));
@@ -39,14 +45,14 @@ public final void runTest(Action0 action) throws InterruptedException {
      */
     public long baseline() {
         LongSumObserver o = new LongSumObserver();
-        for (long l = 0; l < REPETITIONS; l++) {
+        for (long l = 0; l < repetitions; l++) {
             o.onNext(l);
         }
         o.onCompleted();
         return o.sum;
     }
-    
-    public static Iterable ITERABLE_OF_REPETITIONS = new Iterable() {
+
+    public Iterable ITERABLE_OF_REPETITIONS = new Iterable() {
 
         @Override
         public Iterator iterator() {
@@ -55,7 +61,7 @@ public Iterator iterator() {
 
                 @Override
                 public boolean hasNext() {
-                    return count <= REPETITIONS;
+                    return count <= repetitions;
                 }
 
                 @Override
@@ -71,5 +77,5 @@ public void remove() {
             };
         };
     };
-    
+
 }
diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
index b582e9edd0..487f34b558 100644
--- a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
+++ b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -4,6 +4,11 @@
 import rx.util.functions.Action0;
 
 public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
+
+    CompositeSubscriptionAddRemovePerf() {
+        super(REPETITIONS);
+    }
+
     public static void main(String[] args) {
         final CompositeSubscriptionAddRemovePerf spt = new CompositeSubscriptionAddRemovePerf();
         try {

From d5e5df402bf4d18075dbf11f311793399a682e2e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 15:08:26 -0800
Subject: [PATCH 347/441] ObserveOn with Buffer Size

---
 rxjava-core/src/main/java/rx/Observable.java  |  20 ++-
 .../java/rx/operators/OperatorObserveOn.java  | 132 +++++++++++++-----
 .../OperatorObserveOnPerformance.java         |  37 ++++-
 .../rx/operators/OperatorObserveOnTest.java   |  36 +++--
 4 files changed, 172 insertions(+), 53 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e6a3dd4921..7c3ead37a2 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5139,8 +5139,7 @@ public final  ConnectableObservable multicast(Subject
      * 
      * 
@@ -5154,6 +5153,23 @@ public final Observable observeOn(Scheduler scheduler) {
         return lift(new OperatorObserveOn(scheduler));
     }
 
+    /**
+     * Move notifications to the specified {@link Scheduler} asynchronously with a buffer of the given size.
+     * 
    
+     * 
+     * 
+     * @param scheduler
+     *            the {@link Scheduler} to notify {@link Observer}s on
+     * @param bufferSize
+     *            that will be rounded up to the next power of 2
+     * @return the source Observable modified so that its {@link Observer}s are notified on the
+     *         specified {@link Scheduler}
+     * @see RxJava Wiki: observeOn()
+     */
+    public final Observable observeOn(Scheduler scheduler, int bufferSize) {
+        return lift(new OperatorObserveOn(scheduler, bufferSize));
+    }
+    
     /**
      * Filters the items emitted by an Observable, only emitting those of the specified type.
      * 
    
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index b2e10593b5..1b818013e9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -48,9 +48,35 @@
 public class OperatorObserveOn implements Operator {
 
     private final Scheduler scheduler;
+    private final int bufferSize;
 
-    public OperatorObserveOn(Scheduler scheduler) {
+    /**
+     * 
+     * @param scheduler
+     * @param bufferSize
+     *            that will be rounded up to the next power of 2
+     */
+    public OperatorObserveOn(Scheduler scheduler, int bufferSize) {
         this.scheduler = scheduler;
+        this.bufferSize = roundToNextPowerOfTwoIfNecessary(bufferSize);
+    }
+
+    public OperatorObserveOn(Scheduler scheduler) {
+        this(scheduler, 1);
+    }
+
+    private static int roundToNextPowerOfTwoIfNecessary(int num) {
+        if ((num & -num) == num) {
+            return num;
+        } else {
+            int result = 1;
+            while (num != 0)
+            {
+                num >>= 1;
+                result <<= 1;
+            }
+            return result;
+        }
     }
 
     @Override
@@ -87,7 +113,7 @@ private class ObserveOnSubscriber extends Subscriber {
         final Subscriber observer;
         private volatile Scheduler.Inner recursiveScheduler;
 
-        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue();
+        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue(bufferSize);
         final AtomicLong counter = new AtomicLong(0);
 
         public ObserveOnSubscriber(Subscriber observer) {
@@ -101,9 +127,9 @@ public void onNext(final T t) {
                 // we want to block for natural back-pressure
                 // so that the producer waits for each value to be consumed
                 if (t == null) {
-                    queue.put(NULL_SENTINEL);
+                    queue.addBlocking(NULL_SENTINEL);
                 } else {
-                    queue.put(t);
+                    queue.addBlocking(t);
                 }
                 schedule();
             } catch (InterruptedException e) {
@@ -118,7 +144,7 @@ public void onCompleted() {
             try {
                 // we want to block for natural back-pressure
                 // so that the producer waits for each value to be consumed
-                queue.put(COMPLETE_SENTINEL);
+                queue.addBlocking(COMPLETE_SENTINEL);
                 schedule();
             } catch (InterruptedException e) {
                 onError(e);
@@ -130,7 +156,7 @@ public void onError(final Throwable e) {
             try {
                 // we want to block for natural back-pressure
                 // so that the producer waits for each value to be consumed
-                queue.put(new ErrorSentinel(e));
+                queue.addBlocking(new ErrorSentinel(e));
                 schedule();
             } catch (InterruptedException e2) {
                 // call directly if we can't schedule
@@ -195,37 +221,34 @@ private void pollQueue() {
 
     }
 
-    /**
-     * Same behavior as ArrayBlockingQueue(1) except that we can interrupt/unsubscribe it.
-     */
     private class InterruptibleBlockingQueue {
 
-        private final Semaphore semaphore = new Semaphore(1);
-        private volatile Object item;
+        private final Semaphore semaphore;
         private volatile boolean interrupted = false;
 
-        public Object poll() {
-            if (interrupted) {
-                return null;
-            }
-            if (item == null) {
-                return null;
-            }
-            try {
-                return item;
-            } finally {
-                item = null;
-                semaphore.release();
-            }
+        private final Object[] buffer;
+
+        private AtomicLong tail = new AtomicLong();
+        private AtomicLong head = new AtomicLong();
+        private final int capacity;
+        private final int mask;
+
+        public InterruptibleBlockingQueue(final int size) {
+            this.semaphore = new Semaphore(size);
+            this.capacity = size;
+            this.mask = size - 1;
+            buffer = new Object[size];
         }
 
         /**
-         * Add an Object, blocking if an item is already in the queue.
-         * 
-         * @param o
-         * @throws InterruptedException
+         * Used to unsubscribe and interrupt the producer if blocked in put()
          */
-        public void put(Object o) throws InterruptedException {
+        public void interrupt() {
+            interrupted = true;
+            semaphore.release();
+        }
+
+        public void addBlocking(final Object e) throws InterruptedException {
             if (interrupted) {
                 throw new InterruptedException("Interrupted by Unsubscribe");
             }
@@ -233,19 +256,54 @@ public void put(Object o) throws InterruptedException {
             if (interrupted) {
                 throw new InterruptedException("Interrupted by Unsubscribe");
             }
-            if (o == null) {
+            if (e == null) {
                 throw new IllegalArgumentException("Can not put null");
             }
-            item = o;
+
+            if (offer(e)) {
+                return;
+            } else {
+                throw new IllegalStateException("Queue is full");
+            }
         }
 
-        /**
-         * Used to unsubscribe and interrupt the producer if blocked in put()
-         */
-        public void interrupt() {
-            interrupted = true;
-            semaphore.release();
+        private boolean offer(final Object e) {
+            final long _t = tail.get();
+            if (_t - head.get() == capacity) {
+                // queue is full
+                return false;
+            }
+            int index = (int) (_t & mask);
+            buffer[index] = e;
+            // move the tail forward
+            tail.lazySet(_t + 1);
+
+            return true;
         }
+
+        public Object poll() {
+            if (interrupted) {
+                return null;
+            }
+            final long _h = head.get();
+            if (tail.get() == _h) {
+                // nothing available
+                return null;
+            }
+            int index = (int) (_h & mask);
+
+            // fetch the item
+            Object v = buffer[index];
+            // allow GC to happen
+            buffer[index] = null;
+            // increment and signal we're done
+            head.lazySet(_h + 1);
+            if (v != null) {
+                semaphore.release();
+            }
+            return v;
+        }
+
     }
 
 }
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
index c25857ea54..f14b2a25b3 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
@@ -8,7 +8,7 @@
 
 public class OperatorObserveOnPerformance extends AbstractPerformanceTester {
 
-    private static long reps = 1000000;
+    private static long reps = 10000;
 
     OperatorObserveOnPerformance() {
         super(reps);
@@ -34,10 +34,43 @@ public void call() {
     /**
      * Observable.from(1L).observeOn()
      * 
+     * --- version 0.17.1 => with queue size == 1
+     * 
+     * Run: 10 - 115,033 ops/sec
+     * Run: 11 - 118,155 ops/sec
+     * Run: 12 - 120,526 ops/sec
+     * Run: 13 - 115,035 ops/sec
+     * Run: 14 - 116,102 ops/sec
+     * 
+     * --- version 0.17.1 => with queue size == 16
+     * 
+     * Run: 10 - 850,412 ops/sec
+     * Run: 11 - 711,642 ops/sec
+     * Run: 12 - 788,332 ops/sec
+     * Run: 13 - 1,064,056 ops/sec
+     * Run: 14 - 656,857 ops/sec
+     * 
+     * --- version 0.17.1 => with queue size == 1000000
+     * 
+     * Run: 10 - 5,162,622 ops/sec
+     * Run: 11 - 5,271,481 ops/sec
+     * Run: 12 - 4,442,470 ops/sec
+     * Run: 13 - 5,149,330 ops/sec
+     * Run: 14 - 5,146,680 ops/sec
+     * 
+     * --- version 0.16.1
+     * 
+     * Run: 10 - 27,098,802 ops/sec
+     * Run: 11 - 24,204,284 ops/sec
+     * Run: 12 - 27,208,663 ops/sec
+     * Run: 13 - 26,879,552 ops/sec
+     * Run: 14 - 26,658,846 ops/sec
+     * 
+     * 
      */
     public long timeObserveOn() {
 
-        Observable s = Observable.range(1, (int) reps).observeOn(Schedulers.newThread());
+        Observable s = Observable.range(1, (int) reps).observeOn(Schedulers.newThread(), 16);
         IntegerSumObserver o = new IntegerSumObserver();
         s.subscribe(o);
         return o.sum;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 5afa2729d6..7e522eccef 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -348,30 +348,35 @@ public void onNext(Integer t) {
 
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThread() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread());
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 1);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThreadAndBuffer8() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 8);
     }
 
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeIO() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.io());
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.io(), 1);
     }
 
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTrampoline() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.trampoline());
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.trampoline(), 1);
     }
 
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTestScheduler() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.test());
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.test(), 1);
     }
 
     @Test
     public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeComputation() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.computation());
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.computation(), 1);
     }
 
-    private final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Scheduler scheduler) throws InterruptedException {
+    private final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Scheduler scheduler, int bufferSize) throws InterruptedException {
         final AtomicInteger countEmitted = new AtomicInteger();
         final AtomicInteger countTaken = new AtomicInteger();
         int value = Observable.create(new OnSubscribeFunc() {
@@ -385,7 +390,7 @@ public Subscription onSubscribe(final Observer o) {
                     public void run() {
                         int i = 1;
                         while (!s.isUnsubscribed() && i <= 100) {
-                            System.out.println("onNext from fast producer [" + Thread.currentThread() + "]: " + i);
+                            //                            System.out.println("onNext from fast producer [" + Thread.currentThread() + "]: " + i);
                             o.onNext(i++);
                         }
                         o.onCompleted();
@@ -405,13 +410,13 @@ public void call(Integer i) {
 
             @Override
             public void call() {
-                System.out.println("-------- Done Emitting from Source ---------");
+                //                System.out.println("-------- Done Emitting from Source ---------");
             }
-        }).observeOn(scheduler).doOnNext(new Action1() {
+        }).observeOn(scheduler, bufferSize).doOnNext(new Action1() {
 
             @Override
             public void call(Integer i) {
-                System.out.println(">> onNext to slowConsumer  [" + Thread.currentThread() + "] pre-take: " + i);
+                //                System.out.println(">> onNext to slowConsumer  [" + Thread.currentThread() + "] pre-take: " + i);
                 //force it to be slower than the producer
                 try {
                     Thread.sleep(10);
@@ -420,7 +425,14 @@ public void call(Integer i) {
                 }
                 countTaken.incrementAndGet();
             }
-        }).take(10).toBlockingObservable().last();
+        }).take(10).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer t) {
+                System.out.println("*********** value: " + t);
+            }
+
+        }).toBlockingObservable().last();
 
         if (scheduler instanceof TrampolineScheduler || scheduler instanceof ImmediateScheduler || scheduler instanceof TestScheduler) {
             // since there is no concurrency it will block and only emit as many as it can process
@@ -428,7 +440,7 @@ public void call(Integer i) {
         } else {
             // the others with concurrency should not emit all 100 ... but 10 + 2 in the pipeline
             // NOTE: The +2 could change if the implementation of the queue logic changes. See Javadoc at top of class.
-            assertEquals(12, countEmitted.get());
+            assertEquals(11, countEmitted.get(), bufferSize); // can be up to 11 + bufferSize
         }
         // number received after take (but take will filter any extra)
         assertEquals(10, value);

From 589d360888d0c45c7b3d702fd517f43681282e0c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 17:05:02 -0800
Subject: [PATCH 348/441] Observer -> Subscriber

---
 .../src/perf/java/rx/operators/ObservableBenchmark.java        | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
index 3cfac3d3a5..e35815f82d 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -12,6 +12,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
 import rx.util.functions.Func1;
 
 public class ObservableBenchmark {
@@ -105,7 +106,7 @@ private static void awaitAllObservers() {
 
     private static final Observable observableOfInts = Observable.create(new OnSubscribe() {
         @Override
-        public void call(Observer o) {
+        public void call(Subscriber o) {
             for (int i = 0; i < intValues.length; i++) {
                 if (o.isUnsubscribed())
                     return;

From 867df14ec40cb00035c74704628cd7c0c322b491 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 17:27:53 -0800
Subject: [PATCH 349/441] Rename OperatorFromIterable to
 OnSubscribeFromIterable

---
 rxjava-core/src/main/java/rx/Observable.java           |  6 +++---
 ...rFromIterable.java => OnSubscribeFromIterable.java} |  4 ++--
 .../java/rx/operators/OperatorFromIterableTest.java    | 10 ++++++----
 3 files changed, 11 insertions(+), 9 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperatorFromIterable.java => OnSubscribeFromIterable.java} (90%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7c3ead37a2..abd715b10a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -95,7 +95,7 @@
 import rx.operators.OperationWindow;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
-import rx.operators.OperatorFromIterable;
+import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
@@ -1217,7 +1217,7 @@ public final static  Observable from(Future future, Scheduler
      * @see RxJava Wiki: from()
      */
     public final static  Observable from(Iterable iterable) {
-        return create(new OperatorFromIterable(iterable));
+        return create(new OnSubscribeFromIterable(iterable));
     }
 
     /**
@@ -1239,7 +1239,7 @@ public final static  Observable from(Iterable iterable) {
      * @see MSDN: Observable.ToObservable
      */
     public final static  Observable from(Iterable iterable, Scheduler scheduler) {
-        return create(new OperatorFromIterable(iterable)).subscribeOn(scheduler);
+        return create(new OnSubscribeFromIterable(iterable)).subscribeOn(scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFromIterable.java b/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
similarity index 90%
rename from rxjava-core/src/main/java/rx/operators/OperatorFromIterable.java
rename to rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
index 750fa9ba24..45dbde9004 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFromIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
@@ -26,11 +26,11 @@
  * You can convert any object that supports the Iterable interface into an Observable that emits
  * each item in the object, with the toObservable operation.
  */
-public final class OperatorFromIterable implements OnSubscribe {
+public final class OnSubscribeFromIterable implements OnSubscribe {
 
     final Iterable is;
 
-    public OperatorFromIterable(Iterable iterable) {
+    public OnSubscribeFromIterable(Iterable iterable) {
         this.is = iterable;
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
index 2fbc6627da..078482dc3e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
 
@@ -30,7 +32,7 @@ public class OperatorFromIterableTest {
 
     @Test
     public void testIterable() {
-        Observable observable = Observable.create(new OperatorFromIterable(Arrays. asList("one", "two", "three")));
+        Observable observable = Observable.create(new OnSubscribeFromIterable(Arrays. asList("one", "two", "three")));
 
         @SuppressWarnings("unchecked")
         Observer observer = mock(Observer.class);
@@ -41,7 +43,7 @@ public void testIterable() {
         verify(observer, Mockito.never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
-    
+
     @Test
     public void testObservableFromIterable() {
         Observable observable = Observable.from(Arrays. asList("one", "two", "three"));

From 4154c0f7290b2e5d0e9c5b4b4e86a1613805f5e9 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 17:33:17 -0800
Subject: [PATCH 350/441] OnSubscribeRange

---
 rxjava-core/src/main/java/rx/Observable.java  | 12 ++-
 .../java/rx/operators/OnSubscribeRange.java   | 44 +++++++++++
 rxjava-core/src/main/java/rx/util/Range.java  | 75 -------------------
 .../operators/OperatorRangePerformance.java   | 59 +++++++++++++++
 .../rx/operators/OnSubscribeRangeTest.java    | 40 ++++++++++
 .../src/test/java/rx/util/RangeTest.java      | 65 ----------------
 6 files changed, 152 insertions(+), 143 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/Range.java
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/util/RangeTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index abd715b10a..4ed0c4e5fd 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -33,6 +33,7 @@
 import rx.observables.ConnectableObservable;
 import rx.observables.GroupedObservable;
 import rx.observers.SafeSubscriber;
+import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
 import rx.operators.OperationAmb;
 import rx.operators.OperationAny;
@@ -120,7 +121,6 @@
 import rx.subscriptions.Subscriptions;
 import rx.util.Exceptions;
 import rx.util.OnErrorNotImplementedException;
-import rx.util.Range;
 import rx.util.TimeInterval;
 import rx.util.Timestamped;
 import rx.util.functions.Action0;
@@ -2439,7 +2439,10 @@ public final static  Observable> parallelMerge(ObservableMSDN: Observable.Range
      */
     public final static Observable range(int start, int count) {
-        return from(Range.createWithCount(start, count));
+        if ((start + count) > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
+        }
+        return Observable.create(new OnSubscribeRange(start, start + count));
     }
 
     /**
@@ -2459,7 +2462,10 @@ public final static Observable range(int start, int count) {
      * @see MSDN: Observable.Range
      */
     public final static Observable range(int start, int count, Scheduler scheduler) {
-        return from(Range.createWithCount(start, count), scheduler);
+        if ((start + count) > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
+        }
+        return Observable.create(new OnSubscribeRange(start, start + count)).subscribeOn(scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java b/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
new file mode 100644
index 0000000000..8d833be615
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
@@ -0,0 +1,44 @@
+/**
+ * Copyright 2014 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 rx.Observable.OnSubscribe;
+import rx.Subscriber;
+
+/**
+ */
+public final class OnSubscribeRange implements OnSubscribe {
+
+    private final int start;
+    private final int end;
+
+    public OnSubscribeRange(int start, int end) {
+        this.start = start;
+        this.end = end;
+    }
+
+    @Override
+    public void call(Subscriber o) {
+        for (int i = start; i < end; i++) {
+            if (o.isUnsubscribed()) {
+                return;
+            }
+            o.onNext(i);
+        }
+        o.onCompleted();
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/util/Range.java b/rxjava-core/src/main/java/rx/util/Range.java
deleted file mode 100644
index da9cf3713a..0000000000
--- a/rxjava-core/src/main/java/rx/util/Range.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Copyright 2014 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.util;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-public final class Range implements Iterable {
-    private final int start;
-    private final int end;
-    private final int step;
-
-    public static Range createWithCount(int start, int count) {
-        return create(start, start + count);
-    }
-
-    public static Range create(int start, int end) {
-        return new Range(start, end, 1);
-    }
-
-    public static Range createWithStep(int start, int end, int step) {
-        return new Range(start, end, step);
-    }
-
-    private Range(int start, int end, int step) {
-        this.start = start;
-        this.end = end;
-        this.step = step;
-    }
-
-    @Override
-    public Iterator iterator() {
-        return new Iterator() {
-            private int current = start;
-
-            @Override
-            public boolean hasNext() {
-                return current < end;
-            }
-
-            @Override
-            public Integer next() {
-                if (!hasNext()) {
-                    throw new NoSuchElementException("No more elements");
-                }
-                int result = current;
-                current += step;
-                return result;
-            }
-
-            @Override
-            public void remove() {
-                throw new UnsupportedOperationException("Read only iterator");
-            }
-        };
-    }
-
-    @Override
-    public String toString() {
-        return "Range (" + start + ", " + end + "), step " + step;
-    }
-}
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
new file mode 100644
index 0000000000..5004ccc132
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
@@ -0,0 +1,59 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+import rx.util.functions.Action0;
+
+public class OperatorRangePerformance extends AbstractPerformanceTester {
+
+    static int reps = Integer.MAX_VALUE / 8;
+
+    OperatorRangePerformance() {
+        super(reps);
+    }
+
+    public static void main(String args[]) {
+
+        final OperatorRangePerformance spt = new OperatorRangePerformance();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.timeRange();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 
+     * -- 0.17
+     * 
+     * Run: 10 - 271,147,198 ops/sec
+     * Run: 11 - 274,821,481 ops/sec
+     * Run: 12 - 271,632,295 ops/sec
+     * Run: 13 - 277,876,014 ops/sec
+     * Run: 14 - 274,821,763 ops/sec
+     * 
+     * -- 0.16.1
+     * 
+     * Run: 10 - 222,104,280 ops/sec
+     * Run: 11 - 224,311,761 ops/sec
+     * Run: 12 - 222,999,339 ops/sec
+     * Run: 13 - 222,344,174 ops/sec
+     * Run: 14 - 225,247,983 ops/sec
+     * 
+     * @return
+     */
+    public long timeRange() {
+        IntegerSumObserver o = new IntegerSumObserver();
+        Observable.range(1, reps).subscribe(o);
+        return o.sum;
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
new file mode 100644
index 0000000000..d703f0fcc1
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
@@ -0,0 +1,40 @@
+/**
+ * Copyright 2014 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 static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+
+public class OnSubscribeRangeTest {
+
+    @Test
+    public void testRangeStartAt2Count3() {
+        @SuppressWarnings("unchecked")
+        Observer observer = mock(Observer.class);
+        Observable.range(2, 3).subscribe(observer);
+
+        verify(observer, times(1)).onNext(2);
+        verify(observer, times(1)).onNext(3);
+        verify(observer, times(1)).onNext(4);
+        verify(observer, never()).onNext(5);
+        verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/util/RangeTest.java b/rxjava-core/src/test/java/rx/util/RangeTest.java
deleted file mode 100644
index eb7b03d28a..0000000000
--- a/rxjava-core/src/test/java/rx/util/RangeTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/**
- * Copyright 2014 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.util;
-
-import static org.junit.Assert.*;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
-public class RangeTest {
-
-    @Test
-    public void testSimpleRange() {
-        assertEquals(Arrays.asList(1, 2, 3, 4), toList(Range.create(1, 5)));
-    }
-
-    @Test
-    public void testRangeWithStep() {
-        assertEquals(Arrays.asList(1, 3, 5, 7, 9), toList(Range.createWithStep(1, 10, 2)));
-    }
-
-    @Test
-    public void testRangeWithCount() {
-        assertEquals(Arrays.asList(1, 2, 3, 4, 5), toList(Range.createWithCount(1, 5)));
-    }
-
-    @Test
-    public void testRangeWithCount2() {
-        assertEquals(Arrays.asList(2, 3, 4, 5), toList(Range.createWithCount(2, 4)));
-    }
-
-    @Test
-    public void testRangeWithCount3() {
-        assertEquals(Arrays.asList(0, 1, 2, 3), toList(Range.createWithCount(0, 4)));
-    }
-
-    @Test
-    public void testRangeWithCount4() {
-        assertEquals(Arrays.asList(10, 11, 12, 13, 14), toList(Range.createWithCount(10, 5)));
-    }
-
-    private static  List toList(Iterable iterable) {
-        List result = new ArrayList();
-        for (T element : iterable) {
-            result.add(element);
-        }
-        return result;
-    }
-}

From c36cd668564413a59bdf38d12acc47d662887a64 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 8 Feb 2014 19:32:21 -0800
Subject: [PATCH 351/441] Test Unsubscribe

- also cleaned up some stuff I remembered after merging last commits
---
 rxjava-core/src/main/java/rx/Observable.java  | 10 +++----
 .../java/rx/operators/OnSubscribeRange.java   |  3 ++-
 .../rx/operators/OnSubscribeRangeTest.java    | 27 +++++++++++++++++++
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4ed0c4e5fd..b3e8273960 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2439,10 +2439,13 @@ public final static  Observable> parallelMerge(ObservableMSDN: Observable.Range
      */
     public final static Observable range(int start, int count) {
+        if (count < 1) {
+            throw new IllegalArgumentException("Count must be positive");
+        }
         if ((start + count) > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
         }
-        return Observable.create(new OnSubscribeRange(start, start + count));
+        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
     }
 
     /**
@@ -2462,10 +2465,7 @@ public final static Observable range(int start, int count) {
      * @see MSDN: Observable.Range
      */
     public final static Observable range(int start, int count, Scheduler scheduler) {
-        if ((start + count) > Integer.MAX_VALUE) {
-            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
-        }
-        return Observable.create(new OnSubscribeRange(start, start + count)).subscribeOn(scheduler);
+        return range(start, count).subscribeOn(scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java b/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
index 8d833be615..797bb49718 100644
--- a/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
+++ b/rxjava-core/src/main/java/rx/operators/OnSubscribeRange.java
@@ -19,6 +19,7 @@
 import rx.Subscriber;
 
 /**
+ * Emit ints from start to end inclusive.
  */
 public final class OnSubscribeRange implements OnSubscribe {
 
@@ -32,7 +33,7 @@ public OnSubscribeRange(int start, int end) {
 
     @Override
     public void call(Subscriber o) {
-        for (int i = start; i < end; i++) {
+        for (int i = start; i <= end; i++) {
             if (o.isUnsubscribed()) {
                 return;
             }
diff --git a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
index d703f0fcc1..f73eeb5e95 100644
--- a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
@@ -15,12 +15,16 @@
  */
 package rx.operators;
 
+import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
+import rx.util.functions.Action1;
 
 public class OnSubscribeRangeTest {
 
@@ -37,4 +41,27 @@ public void testRangeStartAt2Count3() {
         verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
+
+    @Test
+    public void testRangeUnsubscribe() {
+        @SuppressWarnings("unchecked")
+        Observer observer = mock(Observer.class);
+        final AtomicInteger count = new AtomicInteger();
+        Observable.range(1, 1000).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer t1) {
+                count.incrementAndGet();
+            }
+
+        }).take(3).subscribe(observer);
+
+        verify(observer, times(1)).onNext(1);
+        verify(observer, times(1)).onNext(2);
+        verify(observer, times(1)).onNext(3);
+        verify(observer, never()).onNext(4);
+        verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        assertEquals(3, count.get());
+    }
 }

From 80aa7c618eebc66bf156f96f602b84098ca1342e Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Mon, 10 Feb 2014 14:08:40 -0800
Subject: [PATCH 352/441] Updating StringObservable to use lift And added
 from(InputStream) and from(Reader)

---
 .../java/rx/observables/StringObservable.java | 177 +++++++++++++-----
 .../rx/observables/StringObservableTest.java  |  73 ++++----
 2 files changed, 167 insertions(+), 83 deletions(-)

diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
index 1c7e1e2b1a..4d5ba0474d 100644
--- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
+++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -15,6 +15,9 @@
  */
 package rx.observables;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.CharacterCodingException;
@@ -27,15 +30,72 @@
 import java.util.regex.Pattern;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.operators.Operator;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 public class StringObservable {
+    public static Observable from(final InputStream i) {
+        return from(i, 8 * 1024);
+    }
+
+    public static Observable from(final InputStream i, final int size) {
+        return Observable.create(new OnSubscribe() {
+            @Override
+            public void call(Subscriber o) {
+                byte[] buffer = new byte[size];
+                try {
+                    if (o.isUnsubscribed())
+                        return;
+                    int n = 0;
+                    n = i.read(buffer);
+                    while (n != -1 && !o.isUnsubscribed()) {
+                        o.onNext(Arrays.copyOf(buffer, n));
+                        n = i.read(buffer);
+                    }
+                } catch (IOException e) {
+                    o.onError(e);
+                }
+                if (o.isUnsubscribed())
+                    return;
+                o.onCompleted();
+            }
+        });
+    }
+
+    public static Observable from(final Reader i) {
+        return from(i, 8 * 1024);
+    }
+
+    public static Observable from(final Reader i, final int size) {
+        return Observable.create(new OnSubscribe() {
+            @Override
+            public void call(Subscriber o) {
+                char[] buffer = new char[size];
+                try {
+                    if (o.isUnsubscribed())
+                        return;
+                    int n = 0;
+                    n = i.read(buffer);
+                    while (n != -1 && !o.isUnsubscribed()) {
+                        o.onNext(new String(buffer));
+                        n = i.read(buffer);
+                    }
+                } catch (IOException e) {
+                    o.onError(e);
+                }
+                if (o.isUnsubscribed())
+                    return;
+                o.onCompleted();
+            }
+        });
+    }
+
     /**
-     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams and where handles when a multibyte character spans two chunks.
+     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
+     * and where handles when a multibyte character spans two chunks.
      * 
      * @param src
      * @param charsetName
@@ -46,7 +106,8 @@ public static Observable decode(Observable src, String charsetNa
     }
 
     /**
-     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams and where handles when a multibyte character spans two chunks.
+     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
+     * and where handles when a multibyte character spans two chunks.
      * 
      * @param src
      * @param charset
@@ -57,7 +118,8 @@ public static Observable decode(Observable src, Charset charset)
     }
 
     /**
-     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams and where handles when a multibyte character spans two chunks.
+     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
+     * and where handles when a multibyte character spans two chunks.
      * This method allows for more control over how malformed and unmappable characters are handled.
      * 
      * @param src
@@ -65,22 +127,22 @@ public static Observable decode(Observable src, Charset charset)
      * @return
      */
     public static Observable decode(final Observable src, final CharsetDecoder charsetDecoder) {
-        return Observable.create(new OnSubscribeFunc() {
+        return src.lift(new Operator() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
-                return src.subscribe(new Observer() {
+            public Subscriber call(final Subscriber o) {
+                return new Subscriber(o) {
                     private ByteBuffer leftOver = null;
 
                     @Override
                     public void onCompleted() {
                         if (process(null, leftOver, true))
-                            observer.onCompleted();
+                            o.onCompleted();
                     }
 
                     @Override
                     public void onError(Throwable e) {
                         if (process(null, leftOver, true))
-                            observer.onError(e);
+                            o.onError(e);
                     }
 
                     @Override
@@ -120,7 +182,7 @@ public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
                                 cr.throwException();
                             }
                             catch (CharacterCodingException e) {
-                                observer.onError(e);
+                                o.onError(e);
                                 return false;
                             }
                         }
@@ -134,11 +196,11 @@ public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
 
                         String string = cb.toString();
                         if (!string.isEmpty())
-                            observer.onNext(string);
+                            o.onNext(string);
 
                         return true;
                     }
-                });
+                };
             }
         });
     }
@@ -190,13 +252,14 @@ public byte[] call(String str) {
     }
 
     /**
-     * Gather up all of the strings in to one string to be able to use it as one message. Don't use this on infinite streams.
+     * Gather up all of the strings in to one string to be able to use it as one message. Don't use
+     * this on infinite streams.
      * 
      * @param src
      * @return
      */
     public static Observable stringConcat(Observable src) {
-        return src.aggregate(new Func2() {
+        return src.reduce(new Func2() {
             @Override
             public String call(String a, String b) {
                 return a + b;
@@ -218,22 +281,25 @@ public String call(String a, String b) {
      */
     public static Observable split(final Observable src, String regex) {
         final Pattern pattern = Pattern.compile(regex);
-        return Observable.create(new OnSubscribeFunc() {
+
+        return src.lift(new Operator() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
-                return src.subscribe(new Observer() {
+            public Subscriber call(final Subscriber o) {
+                return new Subscriber(o) {
                     private String leftOver = null;
 
                     @Override
                     public void onCompleted() {
                         output(leftOver);
-                        observer.onCompleted();
+                        if (!o.isUnsubscribed())
+                            o.onCompleted();
                     }
 
                     @Override
                     public void onError(Throwable e) {
                         output(leftOver);
-                        observer.onError(e);
+                        if (!o.isUnsubscribed())
+                            o.onError(e);
                     }
 
                     @Override
@@ -250,8 +316,10 @@ public void onNext(String segment) {
                     }
 
                     private int emptyPartCount = 0;
+
                     /**
                      * when limit == 0 trailing empty parts are not emitted.
+                     * 
                      * @param part
                      */
                     private void output(String part) {
@@ -259,15 +327,18 @@ private void output(String part) {
                             emptyPartCount++;
                         }
                         else {
-                            for(; emptyPartCount>0; emptyPartCount--)
-                                observer.onNext("");
-                            observer.onNext(part);
+                            for (; emptyPartCount > 0; emptyPartCount--)
+                                if (!o.isUnsubscribed())
+                                    o.onNext("");
+                            if (!o.isUnsubscribed())
+                                o.onNext(part);
                         }
                     }
-                });
+                };
             }
         });
     }
+
     /**
      * Concatenates the sequence of values by adding a separator
      * between them and emitting the result once the source completes.
@@ -276,49 +347,55 @@ private void output(String part) {
      * {@link java.lang.String#valueOf(java.lang.Object)} calls.
      * 
    
      * For example:
+     * 
      * 
    -     * Observable<Object> source = Observable.from("a", 1, "c");
-     * Observable<String> result = join(source, ", ");
+     * Observable<Object> source = Observable.from("a", 1, "c");
+     * Observable<String> result = join(source, ", ");
      * 
    
      * 
      * will yield a single element equal to "a, 1, c".
      * 
-     * @param source the source sequence of CharSequence values
-     * @param separator the separator to a
+     * @param source
+     *            the source sequence of CharSequence values
+     * @param separator
+     *            the separator to a
      * @return an Observable which emits a single String value having the concatenated
      *         values of the source observable with the separator between elements
      */
     public static  Observable join(final Observable source, final CharSequence separator) {
-        return Observable.create(new OnSubscribeFunc() {
-
+        return source.lift(new Operator() {
             @Override
-            public Subscription onSubscribe(final Observer t1) {
-                return source.subscribe(new Observer() {
+            public Subscriber call(final Subscriber o) {
+                return new Subscriber(o) {
                     boolean mayAddSeparator;
                     StringBuilder b = new StringBuilder();
+
                     @Override
-                    public void onNext(T args) {
-                        if (mayAddSeparator) {
-                            b.append(separator);
-                        }
-                        mayAddSeparator = true;
-                        b.append(String.valueOf(args));
+                    public void onCompleted() {
+                        String str = b.toString();
+                        b = null;
+                        if (!o.isUnsubscribed())
+                            o.onNext(str);
+                        if (!o.isUnsubscribed())
+                            o.onCompleted();
                     }
 
                     @Override
                     public void onError(Throwable e) {
                         b = null;
-                        t1.onError(e);
+                        if (!o.isUnsubscribed())
+                            o.onError(e);
                     }
 
                     @Override
-                    public void onCompleted() {
-                        String str = b.toString();
-                        b = null;
-                        t1.onNext(str);
-                        t1.onCompleted();
+                    public void onNext(Object t) {
+                        if (mayAddSeparator) {
+                            b.append(separator);
+                        }
+                        mayAddSeparator = true;
+                        b.append(String.valueOf(t));
                     }
-                });
+                };
             }
         });
     }
diff --git a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
index 8b45a44f9e..8b3577b601 100644
--- a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
+++ b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * 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
- *
+ * 
+ * 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.
@@ -23,6 +23,7 @@
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.MalformedInputException;
+import java.util.Arrays;
 
 import org.junit.Test;
 
@@ -110,6 +111,7 @@ public void testEncode() {
     public void testSplitOnCollon() {
         testSplit("boo:and:foo", ":", 0, "boo", "and", "foo");
     }
+
     @Test
     public void testSplitOnOh() {
         testSplit("boo:and:foo", "o", 0, "b", "", ":and:f");
@@ -120,96 +122,101 @@ public void testSplit(String str, String regex, int limit, String... parts) {
         for (int i = 0; i < str.length(); i++) {
             String a = str.substring(0, i);
             String b = str.substring(i, str.length());
-            testSplit(a+"|"+b, regex, limit, Observable.from(a, b), parts);
+            testSplit(a + "|" + b, regex, limit, Observable.from(a, b), parts);
         }
     }
 
     public void testSplit(String message, String regex, int limit, Observable src, String... parts) {
         Observable act = StringObservable.split(src, regex);
         Observable exp = Observable.from(parts);
-        AssertObservable.assertObservableEqualsBlocking("when input is "+message+" and limit = "+ limit, exp, act);
+        AssertObservable.assertObservableEqualsBlocking("when input is " + message + " and limit = " + limit, exp, act);
     }
-    
+
     @Test
     public void testJoinMixed() {
-        Observable source = Observable.from("a", 1, "c");
-        
+        Observable source = Observable. from(Arrays.asList("a", 1, "c"));
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, times(1)).onNext("a, 1, c");
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testJoinWithEmptyString() {
         Observable source = Observable.from("", "b", "c");
-        
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, times(1)).onNext(", b, c");
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testJoinWithNull() {
         Observable source = Observable.from("a", null, "c");
-        
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, times(1)).onNext("a, null, c");
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testJoinSingle() {
         Observable source = Observable.from("a");
-        
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, times(1)).onNext("a");
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testJoinEmpty() {
         Observable source = Observable.empty();
-        
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, times(1)).onNext("");
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
+
     @Test
     public void testJoinThrows() {
-        Observable source = Observable.concat(Observable.just("a"), Observable.error(new RuntimeException("Forced failure")));
-        
+        Observable source = Observable.concat(Observable.just("a"), Observable. error(new RuntimeException("Forced failure")));
+
         Observable result = StringObservable.join(source, ", ");
-        
+
         Observer observer = mock(Observer.class);
-        
+
         result.subscribe(new TestObserver(observer));
-        
+
         verify(observer, never()).onNext("a");
         verify(observer, never()).onCompleted();
         verify(observer, times(1)).onError(any(Throwable.class));

From f43ff07139bca284694431d659cb54b7ded3c387 Mon Sep 17 00:00:00 2001
From: MarioAriasC 
Date: Mon, 10 Feb 2014 22:48:02 +0000
Subject: [PATCH 353/441] Fix problem with Subscription

---
 .../src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt        | 2 +-
 .../src/test/kotlin/rx/lang/kotlin/ExtensionTests.kt          | 4 ++--
 settings.gradle                                               | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt
index 589477bc4f..cf4d3787b3 100644
--- a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt
+++ b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt
@@ -347,7 +347,7 @@ public class BasicKotlinTests:KotlinTests() {
         override fun onSubscribe(op: Observer?): Subscription? {
             op!!.onNext("hello_$count")
             op.onCompleted()
-            return Subscription { }
+            return Subscriptions.empty()!!
         }
 
     }
diff --git a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/ExtensionTests.kt b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/ExtensionTests.kt
index ae2f0f061e..c9fa67a6a1 100644
--- a/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/ExtensionTests.kt
+++ b/language-adaptors/rxjava-kotlin/src/test/kotlin/rx/lang/kotlin/ExtensionTests.kt
@@ -33,7 +33,7 @@ import kotlin.concurrent.thread
 /**
  * This class contains tests using the extension functions provided by the language adaptor.
  */
-public class ExtensionTests:KotlinTests() {
+public class ExtensionTests : KotlinTests() {
 
 
     [Test]
@@ -262,7 +262,7 @@ public class ExtensionTests:KotlinTests() {
     val funOnSubscribe: (Int, Observer) -> Subscription = { counter, observer ->
         observer.onNext("hello_$counter")
         observer.onCompleted()
-        Subscription { }
+        Subscriptions.empty()!!
     }
 
     val asyncObservable: (Observer) -> Subscription = { observer ->
diff --git a/settings.gradle b/settings.gradle
index 2122bb8ff6..22dd94ec82 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -4,7 +4,7 @@ include 'rxjava-core', \
 'language-adaptors:rxjava-clojure', \
 'language-adaptors:rxjava-jruby', \
 'language-adaptors:rxjava-scala', \
-//'language-adaptors:rxjava-kotlin', \
+'language-adaptors:rxjava-kotlin', \
 'rxjava-contrib:rxjava-swing', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \

From ac4063246253089bace19f7a74948a2535ca11d7 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:47:07 -0800
Subject: [PATCH 354/441] OperatorFilter Migrated to Lift Operator

- support synchronous unsubscribe now
---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../java/rx/operators/OperationFilter.java    | 71 ----------------
 .../java/rx/operators/OperatorFilter.java     | 81 +++++++++++++++++++
 ...ilterTest.java => OperatorFilterTest.java} |  7 +-
 4 files changed, 86 insertions(+), 77 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationFilter.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorFilter.java
 rename rxjava-core/src/test/java/rx/operators/{OperationFilterTest.java => OperatorFilterTest.java} (88%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index b3e8273960..0ea0bf727c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -51,7 +51,7 @@
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationElementAt;
-import rx.operators.OperationFilter;
+import rx.operators.OperatorFilter;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
@@ -4440,7 +4440,7 @@ public final Observable exists(Func1 predicate) {
      * @see RxJava Wiki: filter()
      */
     public final Observable filter(Func1 predicate) {
-        return create(OperationFilter.filter(this, predicate));
+        return lift(new OperatorFilter(predicate));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFilter.java b/rxjava-core/src/main/java/rx/operators/OperationFilter.java
deleted file mode 100644
index ada9aa9a29..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationFilter.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Copyright 2014 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 rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.util.functions.Func1;
-
-/**
- * Filters an Observable by discarding any items it emits that do not meet some test.
- * 
    
- * 
- */
-public final class OperationFilter {
-
-    public static  OnSubscribeFunc filter(Observable that, Func1 predicate) {
-        return new Filter(that, predicate);
-    }
-
-    private static class Filter implements OnSubscribeFunc {
-
-        private final Observable that;
-        private final Func1 predicate;
-
-        public Filter(Observable that, Func1 predicate) {
-            this.that = that;
-            this.predicate = predicate;
-        }
-
-        public Subscription onSubscribe(final Observer observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(that.subscribe(new Observer() {
-                public void onNext(T value) {
-                    try {
-                        if (predicate.call(value)) {
-                            observer.onNext(value);
-                        }
-                    } catch (Throwable ex) {
-                        observer.onError(ex);
-                        // this will work if the sequence is asynchronous, it will have no effect on a synchronous observable
-                        subscription.unsubscribe();
-                    }
-                }
-
-                public void onError(Throwable ex) {
-                    observer.onError(ex);
-                }
-
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-            }));
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
new file mode 100644
index 0000000000..6922c23178
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -0,0 +1,81 @@
+/**
+ * Copyright 2014 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 rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observables.GroupedObservable;
+import rx.util.functions.Func1;
+
+/**
+ * Filters an Observable by discarding any items it emits that do not meet some test.
+ * 
    
+ * 
+ */
+public final class OperatorFilter implements Operator {
+
+    private final Func1 predicate;
+
+    public OperatorFilter(Func1 predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Subscriber call(final Subscriber child) {
+        return new Subscriber(child) {
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onNext(T value) {
+                try {
+                    if (predicate.call(value)) {
+                        child.onNext(value);
+                    } else {
+                        /*
+                         * Special casing of GroupedObservable since GroupedObservable ***MUST*** be subscribed to
+                         * otherwise it will block the GroupBy operator. 
+                         * 
+                         * See https://github.com/Netflix/RxJava/issues/844
+                         */
+                        if (value instanceof GroupedObservable) {
+                            System.out.println("value is GroupedObservable");
+                            @SuppressWarnings("rawtypes")
+                            GroupedObservable go = (GroupedObservable) value;
+                            System.out.println("********* unsubscribe from go");
+                            go.take(0).subscribe();
+                        }
+                    }
+                } catch (Throwable ex) {
+                    child.onError(ex);
+                }
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
similarity index 88%
rename from rxjava-core/src/test/java/rx/operators/OperationFilterTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
index d27b573d80..74b0953627 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFilterTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
@@ -17,7 +17,6 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationFilter.*;
 
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -26,18 +25,18 @@
 import rx.Observer;
 import rx.util.functions.Func1;
 
-public class OperationFilterTest {
+public class OperatorFilterTest {
 
     @Test
     public void testFilter() {
         Observable w = Observable.from("one", "two", "three");
-        Observable observable = Observable.create(filter(w, new Func1() {
+        Observable observable = w.filter(new Func1() {
 
             @Override
             public Boolean call(String t1) {
                 return t1.equals("two");
             }
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer observer = mock(Observer.class);

From 5a16e025aaf1bb2ca7fee8c340516d80c5780f94 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:48:33 -0800
Subject: [PATCH 355/441] Split Merge and MergeMaxConcurrent

- Splitting them allows clearer code and avoids use of queue for normal merge.
---
 rxjava-core/src/main/java/rx/Observable.java  |   3 +-
 .../main/java/rx/operators/OperatorMerge.java |  74 ++--------
 .../operators/OperatorMergeMaxConcurrent.java | 135 ++++++++++++++++++
 .../OperatorMergeMaxConcurrentTest.java       | 124 ++++++++++++++++
 .../java/rx/operators/OperatorMergeTest.java  | 128 -----------------
 5 files changed, 275 insertions(+), 189 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0ea0bf727c..a6d82f12e4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -100,6 +100,7 @@
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
+import rx.operators.OperatorMergeMaxConcurrent;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorRepeat;
@@ -1791,7 +1792,7 @@ public final static  Observable merge(ObservableMSDN: Observable.Merge
      */
     public final static  Observable merge(Observable> source, int maxConcurrent) {
-        return source.lift(new OperatorMerge(maxConcurrent)); // any idea how to get these generics working?!
+        return source.lift(new OperatorMergeMaxConcurrent(maxConcurrent)); // any idea how to get these generics working?!
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index 0514fee7c6..c60505cd7b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -15,13 +15,11 @@
  */
 package rx.operators;
 
-import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable;
 import rx.Subscriber;
 import rx.observers.SynchronizedSubscriber;
-import rx.subscriptions.CompositeSubscription;
 
 /**
  * Flattens a list of Observables into one Observable sequence, without any transformation.
@@ -32,33 +30,22 @@
  * Observable, by using the merge operation.
  */
 public final class OperatorMerge implements Operator> {
-    private final int maxConcurrent;
-
-    public OperatorMerge() {
-        maxConcurrent = Integer.MAX_VALUE;
-    }
-
-    public OperatorMerge(int maxConcurrent) {
-        if (maxConcurrent <= 0) {
-            throw new IllegalArgumentException("maxConcurrent must be positive");
-        }
-        this.maxConcurrent = maxConcurrent;
-    }
 
     @Override
     public Subscriber> call(final Subscriber outerOperation) {
 
-        final AtomicInteger completionCounter = new AtomicInteger(1);
-        final AtomicInteger concurrentCounter = new AtomicInteger(1);
-        // Concurrent* since we'll be accessing them from the inner Observers which can be on other threads
-        final ConcurrentLinkedQueue> pending = new ConcurrentLinkedQueue>();
-
         final Subscriber o = new SynchronizedSubscriber(outerOperation);
         return new Subscriber>(outerOperation) {
 
+            private volatile boolean completed = false;
+            private final AtomicInteger runningCount = new AtomicInteger();
+
             @Override
             public void onCompleted() {
-                complete();
+                completed = true;
+                if (runningCount.get() == 0) {
+                    o.onCompleted();
+                }
             }
 
             @Override
@@ -68,53 +55,21 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(Observable innerObservable) {
-                // track so we send onComplete only when all have finished
-                completionCounter.incrementAndGet();
-                // check concurrency
-                if (concurrentCounter.incrementAndGet() > maxConcurrent) {
-                    pending.add(innerObservable);
-                    concurrentCounter.decrementAndGet();
-                } else {
-                    // we are able to proceed
-                    CompositeSubscription innerSubscription = new CompositeSubscription();
-                    outerOperation.add(innerSubscription);
-                    innerObservable.subscribe(new InnerObserver(innerSubscription));
-                }
-            }
-
-            private void complete() {
-                if (completionCounter.decrementAndGet() == 0) {
-                    o.onCompleted();
-                    return;
-                } else {
-                    // not all are completed and some may still need to run
-                    concurrentCounter.decrementAndGet();
-                }
-
-                // do work-stealing on whatever thread we're on and subscribe to pending observables
-                if (concurrentCounter.incrementAndGet() > maxConcurrent) {
-                    // still not space to run
-                    concurrentCounter.decrementAndGet();
-                } else {
-                    // we can run
-                    Observable outstandingObservable = pending.poll();
-                    if (outstandingObservable != null) {
-                        CompositeSubscription innerSubscription = new CompositeSubscription();
-                        outerOperation.add(innerSubscription);
-                        outstandingObservable.subscribe(new InnerObserver(innerSubscription));
-                    }
-                }
+                runningCount.incrementAndGet();
+                innerObservable.subscribe(new InnerObserver());
             }
 
             final class InnerObserver extends Subscriber {
 
-                public InnerObserver(CompositeSubscription cs) {
-                    super(cs);
+                public InnerObserver() {
+                    super(o);
                 }
 
                 @Override
                 public void onCompleted() {
-                    complete();
+                    if (runningCount.decrementAndGet() == 0 && completed) {
+                        o.onCompleted();
+                    }
                 }
 
                 @Override
@@ -132,5 +87,4 @@ public void onNext(T a) {
         };
 
     }
-
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
new file mode 100644
index 0000000000..633d229fde
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
@@ -0,0 +1,135 @@
+/**
+ * Copyright 2014 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 java.util.concurrent.atomic.AtomicInteger;
+
+import rx.Observable;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.observers.SynchronizedSubscriber;
+import rx.schedulers.Schedulers;
+import rx.util.InterruptibleBlockingQueue;
+import rx.util.functions.Action1;
+
+/**
+ * Flattens a list of Observables into one Observable sequence, without any transformation.
+ * 
    
+ * 
+ * 
    
+ * You can combine the items emitted by multiple Observables so that they act like a single
+ * Observable, by using the merge operation.
+ */
+public final class OperatorMergeMaxConcurrent implements Operator> {
+    private final int maxConcurrent;
+
+    public OperatorMergeMaxConcurrent(int maxConcurrent) {
+        if (maxConcurrent <= 0) {
+            throw new IllegalArgumentException("maxConcurrent must be positive");
+        }
+        this.maxConcurrent = maxConcurrent;
+    }
+
+    @Override
+    public Subscriber> call(final Subscriber outerOperation) {
+
+        final AtomicInteger concurrentCounter = new AtomicInteger(0);
+        final InterruptibleBlockingQueue> pending = new InterruptibleBlockingQueue>(maxConcurrent);
+        final Scheduler trampoline = Schedulers.trampoline();
+
+        final Subscriber o = new SynchronizedSubscriber(outerOperation);
+        return new Subscriber>(outerOperation) {
+            private volatile boolean completed = false;
+
+            @Override
+            public void onCompleted() {
+                completed = true;
+                if (concurrentCounter.get() == 0) {
+                    o.onCompleted();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onNext(Observable innerObservable) {
+                // queue (blocking if queue is full)
+                try {
+                    pending.addBlocking(innerObservable);
+                } catch (InterruptedException e) {
+                    o.onError(new RuntimeException("Interrupted while doing a blocking add of the inner Observable", e));
+                }
+
+                if (concurrentCounter.incrementAndGet() <= maxConcurrent) {
+                    trampoline.schedule(recursiveSubscriber(pending.poll()));
+                }
+            }
+
+            Action1 recursiveSubscriber(final Observable innerObservable) {
+                return new Action1() {
+
+                    @Override
+                    public void call(Inner inner) {
+                        innerObservable.subscribe(new InnerObserver(inner));
+                    }
+
+                };
+            }
+
+            private void doPendingWorkIfAny(Inner inner) {
+                Observable o = pending.poll();
+                if (o != null) {
+                    inner.schedule(recursiveSubscriber(o));
+                }
+            }
+
+            final class InnerObserver extends Subscriber {
+                final Inner innerScheduler;
+
+                public InnerObserver(Inner innerScheduler) {
+                    super(o);
+                    this.innerScheduler = innerScheduler;
+                }
+
+                @Override
+                public void onCompleted() {
+                    if (concurrentCounter.decrementAndGet() == 0 && completed) {
+                        o.onCompleted();
+                        return;
+                    }
+                    doPendingWorkIfAny(innerScheduler);
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    o.onError(e);
+                }
+
+                @Override
+                public void onNext(T a) {
+                    o.onNext(a);
+                }
+
+            };
+
+        };
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
new file mode 100644
index 0000000000..3bbae8c1cd
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
@@ -0,0 +1,124 @@
+/**
+ * Copyright 2014 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 static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscription;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.Subscriptions;
+
+public class OperatorMergeMaxConcurrentTest {
+
+    @Mock
+    Observer stringObserver;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testWhenMaxConcurrentIsOne() {
+        for (int i = 0; i < 100; i++) {
+            List> os = new ArrayList>();
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
+
+            List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five");
+            Iterator iter = Observable.merge(os, 1).toBlockingObservable().toIterable().iterator();
+            List actual = new ArrayList();
+            while (iter.hasNext()) {
+                actual.add(iter.next());
+            }
+            assertEquals(expected, actual);
+        }
+    }
+
+    @Test
+    public void testMaxConcurrent() {
+        for (int times = 0; times < 100; times++) {
+            int observableCount = 10;
+            // Test maxConcurrent from 2 to 12
+            int maxConcurrent = 2 + (times % 10);
+            AtomicInteger subscriptionCount = new AtomicInteger(0);
+
+            List> os = new ArrayList>();
+            List scos = new ArrayList();
+            for (int i = 0; i < observableCount; i++) {
+                SubscriptionCheckObservable sco = new SubscriptionCheckObservable(subscriptionCount, maxConcurrent);
+                scos.add(sco);
+                os.add(Observable.create(sco).subscribeOn(Schedulers.computation()));
+            }
+
+            Iterator iter = Observable.merge(os, maxConcurrent).toBlockingObservable().toIterable().iterator();
+            List actual = new ArrayList();
+            while (iter.hasNext()) {
+                actual.add(iter.next());
+            }
+            assertEquals(5 * observableCount, actual.size());
+            for (SubscriptionCheckObservable sco : scos) {
+                assertFalse(sco.failed);
+            }
+        }
+    }
+
+    private static class SubscriptionCheckObservable implements
+            Observable.OnSubscribeFunc {
+
+        private final AtomicInteger subscriptionCount;
+        private final int maxConcurrent;
+        volatile boolean failed = false;
+
+        SubscriptionCheckObservable(AtomicInteger subscriptionCount,
+                int maxConcurrent) {
+            this.subscriptionCount = subscriptionCount;
+            this.maxConcurrent = maxConcurrent;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer t1) {
+            if (subscriptionCount.incrementAndGet() > maxConcurrent) {
+                failed = true;
+            }
+            t1.onNext("one");
+            t1.onNext("two");
+            t1.onNext("three");
+            t1.onNext("four");
+            t1.onNext("five");
+            // We could not decrement subscriptionCount in the unsubscribe method
+            // as "unsubscribe" is not guaranteed to be called before the next "subscribe".
+            subscriptionCount.decrementAndGet();
+            t1.onCompleted();
+            return Subscriptions.empty();
+        }
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 6a96a8fc6e..f90f8ad3be 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -20,8 +20,6 @@
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -37,7 +35,6 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
@@ -350,51 +347,6 @@ public void run() {
         }
     }
 
-    /**
-     * A Observable that doesn't do the right thing on UnSubscribe/Error/etc in that it will keep sending events down the pipe regardless of what happens.
-     */
-    private static class TestObservable implements Observable.OnSubscribeFunc {
-
-        Observer observer = null;
-        volatile boolean unsubscribed = false;
-        Subscription s = new Subscription() {
-
-            @Override
-            public void unsubscribe() {
-                unsubscribed = true;
-
-            }
-
-            @Override
-            public boolean isUnsubscribed() {
-                return unsubscribed;
-            }
-
-        };
-
-        /* used to simulate subscription */
-        public void sendOnCompleted() {
-            observer.onCompleted();
-        }
-
-        /* used to simulate subscription */
-        public void sendOnNext(String value) {
-            observer.onNext(value);
-        }
-
-        /* used to simulate subscription */
-        @SuppressWarnings("unused")
-        public void sendOnError(Throwable e) {
-            observer.onError(e);
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            this.observer = observer;
-            return s;
-        }
-    }
-
     private static class TestErrorObservable implements Observable.OnSubscribeFunc {
 
         String[] valuesToReturn;
@@ -420,84 +372,4 @@ public Subscription onSubscribe(Observer observer) {
         }
     }
 
-    @Test
-    public void testWhenMaxConcurrentIsOne() {
-        for (int i = 0; i < 100; i++) {
-            List> os = new ArrayList>();
-            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
-            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
-            os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
-
-            List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five");
-            Iterator iter = Observable.merge(os, 1).toBlockingObservable().toIterable().iterator();
-            List actual = new ArrayList();
-            while (iter.hasNext()) {
-                actual.add(iter.next());
-            }
-            assertEquals(expected, actual);
-        }
-    }
-
-    @Test
-    public void testMaxConcurrent() {
-        for (int times = 0; times < 100; times++) {
-            int observableCount = 100;
-            // Test maxConcurrent from 2 to 12
-            int maxConcurrent = 2 + (times % 10);
-            AtomicInteger subscriptionCount = new AtomicInteger(0);
-
-            List> os = new ArrayList>();
-            List scos = new ArrayList();
-            for (int i = 0; i < observableCount; i++) {
-                SubscriptionCheckObservable sco = new SubscriptionCheckObservable(
-                        subscriptionCount, maxConcurrent);
-                scos.add(sco);
-                os.add(Observable.create(sco).subscribeOn(
-                        Schedulers.computation()));
-            }
-
-            Iterator iter = Observable.merge(os, maxConcurrent)
-                    .toBlockingObservable().toIterable().iterator();
-            List actual = new ArrayList();
-            while (iter.hasNext()) {
-                actual.add(iter.next());
-            }
-            assertEquals(5 * observableCount, actual.size());
-            for (SubscriptionCheckObservable sco : scos) {
-                assertFalse(sco.failed);
-            }
-        }
-    }
-
-    private static class SubscriptionCheckObservable implements
-            Observable.OnSubscribeFunc {
-
-        private final AtomicInteger subscriptionCount;
-        private final int maxConcurrent;
-        volatile boolean failed = false;
-
-        SubscriptionCheckObservable(AtomicInteger subscriptionCount,
-                int maxConcurrent) {
-            this.subscriptionCount = subscriptionCount;
-            this.maxConcurrent = maxConcurrent;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            if (subscriptionCount.incrementAndGet() > maxConcurrent) {
-                failed = true;
-            }
-            t1.onNext("one");
-            t1.onNext("two");
-            t1.onNext("three");
-            t1.onNext("four");
-            t1.onNext("five");
-            // We could not decrement subscriptionCount in the unsubscribe method
-            // as "unsubscribe" is not guaranteed to be called before the next "subscribe".
-            subscriptionCount.decrementAndGet();
-            t1.onCompleted();
-            return Subscriptions.empty();
-        }
-
-    }
 }

From 31101f05882a9b9a020bf6888db5f941ce996b3e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:49:11 -0800
Subject: [PATCH 356/441] InterruptibleBlockingQueue

- used in MergeMaxConcurrent and ObserveOn
- allows for blocking onNext calls when full while still supporting unsubscribe.
---
 .../rx/util/InterruptibleBlockingQueue.java   | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java

diff --git a/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java b/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
new file mode 100644
index 0000000000..5083d6c153
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
@@ -0,0 +1,90 @@
+package rx.util;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class InterruptibleBlockingQueue {
+
+    private final Semaphore semaphore;
+    private volatile boolean interrupted = false;
+
+    private final E[] buffer;
+
+    private AtomicLong tail = new AtomicLong();
+    private AtomicLong head = new AtomicLong();
+    private final int capacity;
+    private final int mask;
+
+    @SuppressWarnings("unchecked")
+    public InterruptibleBlockingQueue(final int size) {
+        this.semaphore = new Semaphore(size);
+        this.capacity = size;
+        this.mask = size - 1;
+        buffer = (E[])new Object[size];
+    }
+
+    /**
+     * Used to unsubscribe and interrupt the producer if blocked in put()
+     */
+    public void interrupt() {
+        interrupted = true;
+        semaphore.release();
+    }
+
+    public void addBlocking(final E e) throws InterruptedException {
+        if (interrupted) {
+            throw new InterruptedException("Interrupted by Unsubscribe");
+        }
+        semaphore.acquire();
+        if (interrupted) {
+            throw new InterruptedException("Interrupted by Unsubscribe");
+        }
+        if (e == null) {
+            throw new IllegalArgumentException("Can not put null");
+        }
+
+        if (offer(e)) {
+            return;
+        } else {
+            throw new IllegalStateException("Queue is full");
+        }
+    }
+
+    private boolean offer(final E e) {
+        final long _t = tail.get();
+        if (_t - head.get() == capacity) {
+            // queue is full
+            return false;
+        }
+        int index = (int) (_t & mask);
+        buffer[index] = e;
+        // move the tail forward
+        tail.lazySet(_t + 1);
+
+        return true;
+    }
+
+    public E poll() {
+        if (interrupted) {
+            return null;
+        }
+        final long _h = head.get();
+        if (tail.get() == _h) {
+            // nothing available
+            return null;
+        }
+        int index = (int) (_h & mask);
+
+        // fetch the item
+        E v = buffer[index];
+        // allow GC to happen
+        buffer[index] = null;
+        // increment and signal we're done
+        head.lazySet(_h + 1);
+        if (v != null) {
+            semaphore.release();
+        }
+        return v;
+    }
+
+}

From eba6b93b4fcae8f9b2839f13744ecb59ff0527c9 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:50:13 -0800
Subject: [PATCH 357/441] Observable.nest()

Make this public so that operator chaining can use it.
Usage would be someObservable.nest().lift(f) for lifting a function that expects Observable> such as `repeat`.
---
 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 a6d82f12e4..84b30c7854 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2362,7 +2362,7 @@ public final static > Observable min(Observab
      * 
      * @return
      */
-    private final Observable> nest() {
+    public final Observable> nest() {
         return from(this);
     }
     

From f1b46a925057cf042da955d759ebe2a8970db4d6 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:52:37 -0800
Subject: [PATCH 358/441] GroupBy Fixes

- There were bugs in the implementation, this fixes some of them. In particular, it was unsubscribing from the parent when all children were completed, and that would unsubscribe even if new groups were going to come.
- There are still problems related to `subscribeOn` and the "time gap" that are being played with. Unit tests related to that are still failing.
---
 .../java/rx/operators/OperatorGroupBy.java    |  24 +-
 .../rx/operators/OperatorGroupByTest.java     | 443 +++++++++++++++---
 2 files changed, 405 insertions(+), 62 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 6226461876..c5142ebaea 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -17,12 +17,14 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
+import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
@@ -47,18 +49,20 @@ public Subscriber call(final Subscriber(new CompositeSubscription()) {
-            private final Map> groups = new HashMap>();
+            private final Map> groups = new HashMap>();
             private final AtomicInteger completionCounter = new AtomicInteger(0);
+            private final AtomicBoolean completed = new AtomicBoolean(false);
 
             @Override
             public void onCompleted() {
+                completed.set(true);
                 // if we receive onCompleted from our parent we onComplete children
-                for (PublishSubject ps : groups.values()) {
+                for (Subject ps : groups.values()) {
                     ps.onCompleted();
                 }
 
+                // special case for empty (no groups emitted)
                 if (completionCounter.get() == 0) {
-                    // special case if no children are running (such as an empty sequence, or just getting the groups and not subscribing)
                     childObserver.onCompleted();
                 }
             }
@@ -73,7 +77,7 @@ public void onError(Throwable e) {
             public void onNext(T t) {
                 try {
                     final K key = keySelector.call(t);
-                    PublishSubject gps = groups.get(key);
+                    Subject gps = groups.get(key);
                     if (gps == null) {
                         // this group doesn't exist
                         if (childObserver.isUnsubscribed()) {
@@ -81,7 +85,7 @@ public void onNext(T t) {
                             return;
                         }
                         gps = PublishSubject.create();
-                        final PublishSubject _gps = gps;
+                        final Subject _gps = gps;
 
                         GroupedObservable go = new GroupedObservable(key, new OnSubscribe() {
 
@@ -130,9 +134,13 @@ public void onNext(T t) {
             }
 
             private void completeInner() {
-                if (completionCounter.decrementAndGet() == 0) {
-                    unsubscribe();
-                    for (PublishSubject ps : groups.values()) {
+                if (completionCounter.decrementAndGet() == 0 && (completed.get() || childObserver.isUnsubscribed())) {
+                    System.out.println("groupBy INNER completed");
+                    if (childObserver.isUnsubscribed()) {
+                        // if the entire groupBy has been unsubscribed and children are completed we will propagate the unsubscribe up.
+                        unsubscribe();
+                    }
+                    for (Subject ps : groups.values()) {
                         ps.onCompleted();
                     }
                     childObserver.onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 92b085ea0f..2fe8130caf 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.*;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Map;
@@ -37,6 +38,7 @@
 import rx.observables.GroupedObservable;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 
@@ -243,6 +245,8 @@ public void testUnsubscribeOnNestedTakeAndSyncInfiniteStream() throws Interrupte
         final AtomicInteger subscribeCounter = new AtomicInteger();
         final AtomicInteger sentEventCounter = new AtomicInteger();
         doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(SYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter);
+        Thread.sleep(500);
+        assertEquals(39, sentEventCounter.get());
     }
 
     /*
@@ -253,6 +257,8 @@ public void testUnsubscribeOnNestedTakeAndAsyncInfiniteStream() throws Interrupt
         final AtomicInteger subscribeCounter = new AtomicInteger();
         final AtomicInteger sentEventCounter = new AtomicInteger();
         doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(ASYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter);
+        Thread.sleep(500);
+        assertEquals(39, sentEventCounter.get());
     }
 
     private void doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(Observable es, AtomicInteger subscribeCounter) throws InterruptedException {
@@ -272,7 +278,7 @@ public Integer call(Event e) {
 
                     @Override
                     public Observable call(GroupedObservable eventGroupedObservable) {
-                        //                        System.out.println("testUnsubscribe => GroupedObservable Key: " + eventGroupedObservable.getKey());
+                        System.out.println("testUnsubscribe => GroupedObservable Key: " + eventGroupedObservable.getKey());
                         groupCounter.incrementAndGet();
 
                         return eventGroupedObservable
@@ -416,57 +422,6 @@ public void call(String s) {
         assertEquals(37, sentEventCounter.get());
     }
 
-    @Test
-    public void testUnsubscribeOnGroupViaOnlyTakeOnInner() {
-        final AtomicInteger subscribeCounter = new AtomicInteger();
-        final AtomicInteger sentEventCounter = new AtomicInteger();
-        final AtomicInteger eventCounter = new AtomicInteger();
-
-        SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter)
-                .groupBy(new Func1() {
-
-                    @Override
-                    public Integer call(Event e) {
-                        return e.source;
-                    }
-                })
-                .flatMap(new Func1, Observable>() {
-
-                    @Override
-                    public Observable call(GroupedObservable eventGroupedObservable) {
-                        int numToTake = 0;
-                        if (eventGroupedObservable.getKey() == 1) {
-                            numToTake = 10;
-                        } else if (eventGroupedObservable.getKey() == 2) {
-                            numToTake = 5;
-                        }
-                        return eventGroupedObservable
-                                .take(numToTake)
-                                .map(new Func1() {
-
-                                    @Override
-                                    public String call(Event event) {
-                                        return "testUnsubscribe => Source: " + event.source + "  Message: " + event.message;
-                                    }
-                                });
-
-                    }
-                })
-                .subscribe(new Action1() {
-
-                    @Override
-                    public void call(String s) {
-                        eventCounter.incrementAndGet();
-                        System.out.println("=> " + s);
-                    }
-
-                });
-
-        assertEquals(15, eventCounter.get());
-        // we should send 22 additional events that are filtered out as they are skipped while taking the 15 we want
-        assertEquals(37, sentEventCounter.get());
-    }
-
     @Test
     public void testStaggeredCompletion() throws InterruptedException {
         final AtomicInteger eventCounter = new AtomicInteger();
@@ -486,7 +441,6 @@ public Observable call(GroupedObservable group) {
                         if (group.getKey() == 0) {
                             return group.delay(100, TimeUnit.MILLISECONDS).map(new Func1() {
 
-                                @Override
                                 public Integer call(Integer t) {
                                     return t * 10;
                                 }
@@ -525,7 +479,7 @@ public void onNext(Integer s) {
         assertEquals(100, eventCounter.get());
     }
 
-    @Test
+    @Test(timeout = 1000)
     public void testCompletionIfInnerNotSubscribed() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicInteger eventCounter = new AtomicInteger();
@@ -562,6 +516,387 @@ public void onNext(GroupedObservable s) {
         assertEquals(2, eventCounter.get());
     }
 
+    @Test(timeout = 500)
+    public void testFilterGroupsUnsubscribesThem() {
+        final AtomicInteger subscribeCounter = new AtomicInteger();
+        final AtomicInteger sentEventCounter = new AtomicInteger();
+        final AtomicInteger eventCounter = new AtomicInteger();
+
+        SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter)
+                .groupBy(new Func1() {
+
+                    @Override
+                    public Integer call(Event e) {
+                        return e.source;
+                    }
+                })
+                // take 2 of the 4 groups
+                .filter(new Func1, Boolean>() {
+
+                    @Override
+                    public Boolean call(GroupedObservable g) {
+                        return g.getKey() < 2;
+                    }
+
+                })
+                .flatMap(new Func1, Observable>() {
+
+                    @Override
+                    public Observable call(GroupedObservable eventGroupedObservable) {
+                        return eventGroupedObservable
+                                .map(new Func1() {
+
+                                    @Override
+                                    public String call(Event event) {
+                                        return "testUnsubscribe => Source: " + event.source + "  Message: " + event.message;
+                                    }
+                                });
+
+                    }
+                })
+                .take(30).subscribe(new Action1() {
+
+                    @Override
+                    public void call(String s) {
+                        eventCounter.incrementAndGet();
+                        System.out.println("=> " + s);
+                    }
+
+                });
+
+        assertEquals(30, eventCounter.get());
+        // we should send 30 additional events that are filtered out as they are in the groups we skip
+        assertEquals(60, sentEventCounter.get());
+    }
+
+    @Test
+    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsAndThenComplete() throws InterruptedException {
+        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                try {
+                    first.await();
+                } catch (InterruptedException e) {
+                    sub.onError(e);
+                    return;
+                }
+                sub.onNext(3);
+                sub.onNext(3);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                if (group.getKey() < 3) {
+                    return group.map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "first groups: " + t1;
+                        }
+
+                    })
+                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
+                            .take(2).doOnCompleted(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    first.countDown();
+                                }
+
+                            });
+                } else {
+                    return group.map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "last group: " + t1;
+                        }
+
+                    });
+                }
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(6, results.size());
+    }
+
+    @Test
+    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
+        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                try {
+                    first.await();
+                } catch (InterruptedException e) {
+                    sub.onError(e);
+                    return;
+                }
+                sub.onNext(3);
+                sub.onNext(3);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                if (group.getKey() < 3) {
+                    return group.map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "first groups: " + t1;
+                        }
+
+                    })
+                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
+                            .take(2).doOnCompleted(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    first.countDown();
+                                }
+
+                            });
+                } else {
+                    return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "last group: " + t1;
+                        }
+
+                    });
+                }
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(6, results.size());
+    }
+
+    @Test
+    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenObservesOnAndDelaysAndThenCompletes() throws InterruptedException {
+        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                try {
+                    first.await();
+                } catch (InterruptedException e) {
+                    sub.onError(e);
+                    return;
+                }
+                sub.onNext(3);
+                sub.onNext(3);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                if (group.getKey() < 3) {
+                    return group.map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "first groups: " + t1;
+                        }
+
+                    })
+                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
+                            .take(2).doOnCompleted(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    first.countDown();
+                                }
+
+                            });
+                } else {
+                    return group.observeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "last group: " + t1;
+                        }
+
+                    });
+                }
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(6, results.size());
+    }
+
+    @Test
+    public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                return group.subscribeOn(Schedulers.newThread()).map(new Func1() {
+
+                    @Override
+                    public String call(Integer t1) {
+                        System.out.println("Received: " + t1 + " on group : " + group.getKey());
+                        return "first groups: " + t1;
+                    }
+
+                });
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(4, results.size());
+    }
+
+    @Test
+    public void testGroupsWithNestedObserveOn() throws InterruptedException {
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                return group.observeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+
+                    @Override
+                    public String call(Integer t1) {
+                        return "first groups: " + t1;
+                    }
+
+                });
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(4, results.size());
+    }
+
     private static class Event {
         int source;
         String message;

From 049ba12361fd96e511cf31bf93e9bf52ac795c8b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:53:12 -0800
Subject: [PATCH 359/441] ObserveOn using InterruptibleBlockingQueue

---
 .../java/rx/operators/OperatorObserveOn.java  | 88 +------------------
 1 file changed, 1 insertion(+), 87 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 1b818013e9..79c38b56cf 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,7 +15,6 @@
  */
 package rx.operators;
 
-import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
@@ -25,6 +24,7 @@
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
 import rx.subscriptions.Subscriptions;
+import rx.util.InterruptibleBlockingQueue;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
@@ -94,7 +94,6 @@ public Subscriber call(Subscriber child) {
         } else {
             return new ObserveOnSubscriber(child);
         }
-
     }
 
     private static Object NULL_SENTINEL = new Object();
@@ -221,89 +220,4 @@ private void pollQueue() {
 
     }
 
-    private class InterruptibleBlockingQueue {
-
-        private final Semaphore semaphore;
-        private volatile boolean interrupted = false;
-
-        private final Object[] buffer;
-
-        private AtomicLong tail = new AtomicLong();
-        private AtomicLong head = new AtomicLong();
-        private final int capacity;
-        private final int mask;
-
-        public InterruptibleBlockingQueue(final int size) {
-            this.semaphore = new Semaphore(size);
-            this.capacity = size;
-            this.mask = size - 1;
-            buffer = new Object[size];
-        }
-
-        /**
-         * Used to unsubscribe and interrupt the producer if blocked in put()
-         */
-        public void interrupt() {
-            interrupted = true;
-            semaphore.release();
-        }
-
-        public void addBlocking(final Object e) throws InterruptedException {
-            if (interrupted) {
-                throw new InterruptedException("Interrupted by Unsubscribe");
-            }
-            semaphore.acquire();
-            if (interrupted) {
-                throw new InterruptedException("Interrupted by Unsubscribe");
-            }
-            if (e == null) {
-                throw new IllegalArgumentException("Can not put null");
-            }
-
-            if (offer(e)) {
-                return;
-            } else {
-                throw new IllegalStateException("Queue is full");
-            }
-        }
-
-        private boolean offer(final Object e) {
-            final long _t = tail.get();
-            if (_t - head.get() == capacity) {
-                // queue is full
-                return false;
-            }
-            int index = (int) (_t & mask);
-            buffer[index] = e;
-            // move the tail forward
-            tail.lazySet(_t + 1);
-
-            return true;
-        }
-
-        public Object poll() {
-            if (interrupted) {
-                return null;
-            }
-            final long _h = head.get();
-            if (tail.get() == _h) {
-                // nothing available
-                return null;
-            }
-            int index = (int) (_h & mask);
-
-            // fetch the item
-            Object v = buffer[index];
-            // allow GC to happen
-            buffer[index] = null;
-            // increment and signal we're done
-            head.lazySet(_h + 1);
-            if (v != null) {
-                semaphore.release();
-            }
-            return v;
-        }
-
-    }
-
 }
\ No newline at end of file

From c56f9c79b7a0305e14fd227f3c2b7be1ac44fd05 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:53:41 -0800
Subject: [PATCH 360/441] IllegalStateException if Repeat receives an onError

---
 rxjava-core/src/main/java/rx/operators/OperatorRepeat.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 9f9768cf33..276f52c174 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -63,7 +63,8 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                child.onError(e);
+                // we should never receive this but if we do we pass it on
+                child.onError(new IllegalStateException("Error received on nested Observable.", e));
             }
 
             @Override

From c78a28db15d712d90b25867017ef7cfe9446bdff Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 19:54:26 -0800
Subject: [PATCH 361/441] Migrate from Deprecated Notification Constructors

---
 rxjava-core/src/main/java/rx/subjects/PublishSubject.java | 5 ++---
 rxjava-core/src/main/java/rx/subjects/ReplaySubject.java  | 4 ++--
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 508e561e1d..9a78f17a93 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -20,7 +20,6 @@
 
 import rx.Notification;
 import rx.Observer;
-import rx.Subscriber;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.util.functions.Action1;
 
@@ -100,7 +99,7 @@ public void onCompleted() {
 
             @Override
             public void call(Collection> observers) {
-                lastNotification.set(new Notification());
+                lastNotification.set(Notification. createOnCompleted());
                 for (Observer o : observers) {
                     o.onCompleted();
                 }
@@ -114,7 +113,7 @@ public void onError(final Throwable e) {
 
             @Override
             public void call(Collection> observers) {
-                lastNotification.set(new Notification(e));
+                lastNotification.set(Notification.createOnError(e));
                 for (Observer o : observers) {
                     o.onError(e);
                 }
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index ce5023963c..0b30987b09 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -119,7 +119,7 @@ public void onCompleted() {
 
             @Override
             public void call(Collection> observers) {
-                state.history.complete(new Notification());
+                state.history.complete(Notification.createOnCompleted());
                 for (SubjectObserver o : observers) {
                     if (caughtUp(o)) {
                         o.onCompleted();
@@ -135,7 +135,7 @@ public void onError(final Throwable e) {
 
             @Override
             public void call(Collection> observers) {
-                state.history.complete(new Notification(e));
+                state.history.complete(Notification.createOnError(e));
                 for (SubjectObserver o : observers) {
                     if (caughtUp(o)) {
                         o.onError(e);

From 648a9564f7eaadba37983ee0ecb8bc87e10e7bdf Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 21:57:22 -0800
Subject: [PATCH 362/441] Revert Observable.Range to support 0 for count.

It had been changed to only support >0, put it back to >=0
---
 rxjava-core/src/main/java/rx/Observable.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 84b30c7854..5f586f29e7 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2440,8 +2440,8 @@ public final static  Observable> parallelMerge(ObservableMSDN: Observable.Range
      */
     public final static Observable range(int start, int count) {
-        if (count < 1) {
-            throw new IllegalArgumentException("Count must be positive");
+        if (count < 0) {
+            throw new IllegalArgumentException("Count can not be negative");
         }
         if ((start + count) > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");

From 9e35276aae3875e93c3e1f12c140cb716a2c82ee Mon Sep 17 00:00:00 2001
From: Johan Haleby 
Date: Tue, 11 Feb 2014 06:59:51 +0100
Subject: [PATCH 363/441] Added overloaded createRequest method that takes an
 HttpContext instance

---
 .../java/rx/apache/http/ObservableHttp.java   | 40 ++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
index 1ed64ea838..4ea4a591b2 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
@@ -21,6 +21,8 @@
 import org.apache.http.nio.client.HttpAsyncClient;
 import org.apache.http.nio.client.methods.HttpAsyncMethods;
 import org.apache.http.nio.protocol.HttpAsyncRequestProducer;
+import org.apache.http.protocol.Http.HttpContext;
+import org.apache.http.protocol.BasicHttpContext;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
@@ -134,6 +136,42 @@ public static ObservableHttp createGet(String uri, final
      * @return
      */
     public static ObservableHttp createRequest(final HttpAsyncRequestProducer requestProducer, final HttpAsyncClient client) {
+        return createRequest(requestProducer, client, new BasicHttpContext());
+    }
+
+    /**
+     * Execute request using {@link HttpAsyncRequestProducer} to define HTTP Method, URI and payload (if applicable).
+     * 
    
+     * If the response is chunked (or flushed progressively such as with text/event-stream Server-Sent Events) this will call
+     * {@link Observer#onNext} multiple times.
+     * 
    
+     * Use {@code HttpAsyncMethods.create* } factory methods to create {@link HttpAsyncRequestProducer} instances.
+     * 
    
+     * A client can be retrieved like this:
+     * 
    
+     * 
     {@code      CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault(); } 
    
+     * 
    
+     * A client with custom configurations can be created like this:
+     * 
    
+     * 
     {@code
+     * final RequestConfig requestConfig = RequestConfig.custom()
+     *     .setSocketTimeout(3000)
+     *     .setConnectTimeout(3000).build();
+     * final CloseableHttpAsyncClient httpclient = HttpAsyncClients.custom()
+     *     .setDefaultRequestConfig(requestConfig)
+     *     .setMaxConnPerRoute(20)
+     *     .setMaxConnTotal(50)
+     *     .build();
+     * httpclient.start();
+     * }
    
+     *
+     *
+     * @param requestProducer
+     * @param client
+     * @param context The HttpContext
+     * @return
+     */
+    public static ObservableHttp createRequest(final HttpAsyncRequestProducer requestProducer, final HttpAsyncClient client, final HttpContext context) {
 
         return ObservableHttp.create(new OnSubscribeFunc() {
 
@@ -144,7 +182,7 @@ public Subscription onSubscribe(final Observer o
 
                 // return a Subscription that wraps the Future so it can be cancelled
                 parentSubscription.add(Subscriptions.from(client.execute(requestProducer, new ResponseConsumerDelegate(observer, parentSubscription),
-                        new FutureCallback() {
+                        context, new FutureCallback() {
 
                             @Override
                             public void completed(HttpResponse result) {

From df5afd4414bfe17b8c62c8afad3cac537a505f7c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:06:37 -0800
Subject: [PATCH 364/441] Revert to OperationMergeMaxConcurrent

The new OperatorMerge class still exists, but reverting this one.
I messed up the thread safety and don't have time to figure it out.
---
 rxjava-core/src/main/java/rx/Observable.java  |   8 +-
 .../OperationMergeMaxConcurrent.java          | 219 ++++++++++++++++++
 .../operators/OperatorMergeMaxConcurrent.java | 135 -----------
 ...a => OperationMergeMaxConcurrentTest.java} |  47 ++--
 4 files changed, 250 insertions(+), 159 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
 rename rxjava-core/src/test/java/rx/operators/{OperatorMergeMaxConcurrentTest.java => OperationMergeMaxConcurrentTest.java} (76%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 5f586f29e7..287c26fe95 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -33,6 +33,7 @@
 import rx.observables.ConnectableObservable;
 import rx.observables.GroupedObservable;
 import rx.observers.SafeSubscriber;
+import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
 import rx.operators.OperationAmb;
@@ -51,7 +52,6 @@
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationElementAt;
-import rx.operators.OperatorFilter;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
@@ -96,11 +96,11 @@
 import rx.operators.OperationWindow;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
-import rx.operators.OnSubscribeFromIterable;
+import rx.operators.OperatorFilter;
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
-import rx.operators.OperatorMergeMaxConcurrent;
+import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorRepeat;
@@ -1792,7 +1792,7 @@ public final static  Observable merge(ObservableMSDN: Observable.Merge
      */
     public final static  Observable merge(Observable> source, int maxConcurrent) {
-        return source.lift(new OperatorMergeMaxConcurrent(maxConcurrent)); // any idea how to get these generics working?!
+        return Observable.create(OperationMergeMaxConcurrent.merge(source, maxConcurrent));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
new file mode 100644
index 0000000000..ec27002d4a
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
@@ -0,0 +1,219 @@
+/**
+ * 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 java.util.LinkedList;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.observers.SynchronizedObserver;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Flattens a list of Observables into one Observable sequence, without any transformation.
+ * 
    
+ * 
+ * 
    
+ * You can combine the items emitted by multiple Observables so that they act like a single
+ * Observable, by using the merge operation.
+ */
+public final class OperationMergeMaxConcurrent {
+
+    public static  OnSubscribeFunc merge(final Observable> o, final int maxConcurrent) {
+        if (maxConcurrent <= 0) {
+            throw new IllegalArgumentException("maxConcurrent must be positive");
+        }
+        return new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(Observer observer) {
+                return new MergeObservable(o, maxConcurrent).onSubscribe(observer);
+            }
+        };
+    }
+
+    /**
+     * This class is NOT thread-safe if invoked and referenced multiple times. In other words, don't subscribe to it multiple times from different threads.
+     * 
    
+     * It IS thread-safe from within it while receiving onNext events from multiple threads.
+     * 
    
+     * This should all be fine as long as it's kept as a private class and a new instance created from static factory method above.
+     * 
    
+     * Note how the take() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
+     * 
+     * @param 
+     */
+    private static final class MergeObservable implements OnSubscribeFunc {
+        private final Observable> sequences;
+        private final CompositeSubscription ourSubscription = new CompositeSubscription();
+        private volatile boolean parentCompleted = false;
+        private final LinkedList> pendingObservables = new LinkedList>();
+        private volatile int activeObservableCount = 0;
+        private final int maxConcurrent;
+        /**
+         * Protect both pendingObservables and activeObservableCount from concurrent accesses.
+         */
+        private final Object gate = new Object();
+
+        private MergeObservable(Observable> sequences, int maxConcurrent) {
+            this.sequences = sequences;
+            this.maxConcurrent = maxConcurrent;
+        }
+
+        public Subscription onSubscribe(Observer actualObserver) {
+
+            /**
+             * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting.
+             * 
    
+             * The calls from each sequence must be serialized.
+             * 
    
+             * Bug report: https://github.com/Netflix/RxJava/issues/200
+             */
+            SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription);
+            SynchronizedObserver synchronizedObserver = new SynchronizedObserver(
+                    new SafeObserver(subscription, actualObserver), // Create a SafeObserver as SynchronizedObserver does not automatically unsubscribe
+                    subscription);
+
+            /**
+             * Subscribe to the parent Observable to get to the children Observables
+             */
+            ourSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver)));
+
+            return subscription;
+        }
+
+        /**
+         * Subscribe to the top level Observable to receive the sequence of Observable children.
+         * 
+         * @param 
+         */
+        private class ParentObserver implements Observer> {
+            private final SynchronizedObserver synchronizedObserver;
+
+            public ParentObserver(SynchronizedObserver synchronizedObserver) {
+                this.synchronizedObserver = synchronizedObserver;
+            }
+
+            @Override
+            public void onCompleted() {
+                parentCompleted = true;
+                if (ourSubscription.isUnsubscribed()) {
+                    return;
+                }
+                // this *can* occur before the children are done, so if it does we won't send onCompleted
+                // but will let the child worry about it
+                // if however this completes and there are no children processing, then we will send onCompleted
+                if (isStopped()) {
+                    synchronizedObserver.onCompleted();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronizedObserver.onError(e);
+            }
+
+            @Override
+            public void onNext(Observable childObservable) {
+                if (ourSubscription.isUnsubscribed()) {
+                    // we won't act on any further items
+                    return;
+                }
+
+                if (childObservable == null) {
+                    throw new IllegalArgumentException("Observable can not be null.");
+                }
+
+                Observable observable = null;
+                synchronized (gate) {
+                    if (activeObservableCount >= maxConcurrent) {
+                        pendingObservables.add(childObservable);
+                    }
+                    else {
+                        observable = childObservable;
+                        activeObservableCount++;
+                    }
+                }
+                if (observable != null) {
+                    ourSubscription.add(observable.subscribe(new ChildObserver(
+                            synchronizedObserver)));
+                }
+            }
+        }
+
+        /**
+         * Subscribe to each child Observable and forward their sequence of data to the actualObserver
+         * 
+         */
+        private class ChildObserver implements Observer {
+
+            private final SynchronizedObserver synchronizedObserver;
+
+            public ChildObserver(SynchronizedObserver synchronizedObserver) {
+                this.synchronizedObserver = synchronizedObserver;
+            }
+
+            @Override
+            public void onCompleted() {
+                if (ourSubscription.isUnsubscribed()) {
+                    return;
+                }
+
+                Observable childObservable = null;
+                // Try to fetch a pending observable
+                synchronized (gate) {
+                    childObservable = pendingObservables.poll();
+                    if (childObservable == null) {
+                        // There is no pending observable, decrease activeObservableCount.
+                        activeObservableCount--;
+                    }
+                    else {
+                        // Fetch an observable successfully.
+                        // We will subscribe(this) at once. So don't change activeObservableCount.
+                    }
+                }
+                if (childObservable != null) {
+                    ourSubscription.add(childObservable.subscribe(this));
+                } else {
+                    // No pending observable. Need to check if it's necessary to emit an onCompleted
+                    if (isStopped()) {
+                        synchronizedObserver.onCompleted();
+                    }
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                synchronizedObserver.onError(e);
+            }
+
+            @Override
+            public void onNext(T args) {
+                synchronizedObserver.onNext(args);
+            }
+
+        }
+
+        private boolean isStopped() {
+            synchronized (gate) {
+                return parentCompleted && activeObservableCount == 0
+                        && pendingObservables.size() == 0;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
deleted file mode 100644
index 633d229fde..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * Copyright 2014 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 java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscriber;
-import rx.observers.SynchronizedSubscriber;
-import rx.schedulers.Schedulers;
-import rx.util.InterruptibleBlockingQueue;
-import rx.util.functions.Action1;
-
-/**
- * Flattens a list of Observables into one Observable sequence, without any transformation.
- * 
    
- * 
- * 
    
- * You can combine the items emitted by multiple Observables so that they act like a single
- * Observable, by using the merge operation.
- */
-public final class OperatorMergeMaxConcurrent implements Operator> {
-    private final int maxConcurrent;
-
-    public OperatorMergeMaxConcurrent(int maxConcurrent) {
-        if (maxConcurrent <= 0) {
-            throw new IllegalArgumentException("maxConcurrent must be positive");
-        }
-        this.maxConcurrent = maxConcurrent;
-    }
-
-    @Override
-    public Subscriber> call(final Subscriber outerOperation) {
-
-        final AtomicInteger concurrentCounter = new AtomicInteger(0);
-        final InterruptibleBlockingQueue> pending = new InterruptibleBlockingQueue>(maxConcurrent);
-        final Scheduler trampoline = Schedulers.trampoline();
-
-        final Subscriber o = new SynchronizedSubscriber(outerOperation);
-        return new Subscriber>(outerOperation) {
-            private volatile boolean completed = false;
-
-            @Override
-            public void onCompleted() {
-                completed = true;
-                if (concurrentCounter.get() == 0) {
-                    o.onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                o.onError(e);
-            }
-
-            @Override
-            public void onNext(Observable innerObservable) {
-                // queue (blocking if queue is full)
-                try {
-                    pending.addBlocking(innerObservable);
-                } catch (InterruptedException e) {
-                    o.onError(new RuntimeException("Interrupted while doing a blocking add of the inner Observable", e));
-                }
-
-                if (concurrentCounter.incrementAndGet() <= maxConcurrent) {
-                    trampoline.schedule(recursiveSubscriber(pending.poll()));
-                }
-            }
-
-            Action1 recursiveSubscriber(final Observable innerObservable) {
-                return new Action1() {
-
-                    @Override
-                    public void call(Inner inner) {
-                        innerObservable.subscribe(new InnerObserver(inner));
-                    }
-
-                };
-            }
-
-            private void doPendingWorkIfAny(Inner inner) {
-                Observable o = pending.poll();
-                if (o != null) {
-                    inner.schedule(recursiveSubscriber(o));
-                }
-            }
-
-            final class InnerObserver extends Subscriber {
-                final Inner innerScheduler;
-
-                public InnerObserver(Inner innerScheduler) {
-                    super(o);
-                    this.innerScheduler = innerScheduler;
-                }
-
-                @Override
-                public void onCompleted() {
-                    if (concurrentCounter.decrementAndGet() == 0 && completed) {
-                        o.onCompleted();
-                        return;
-                    }
-                    doPendingWorkIfAny(innerScheduler);
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    o.onError(e);
-                }
-
-                @Override
-                public void onNext(T a) {
-                    o.onNext(a);
-                }
-
-            };
-
-        };
-
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
similarity index 76%
rename from rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
rename to rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
index 3bbae8c1cd..786dd6821e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
@@ -34,7 +34,7 @@
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
-public class OperatorMergeMaxConcurrentTest {
+public class OperationMergeMaxConcurrentTest {
 
     @Mock
     Observer stringObserver;
@@ -65,7 +65,7 @@ public void testWhenMaxConcurrentIsOne() {
     @Test
     public void testMaxConcurrent() {
         for (int times = 0; times < 100; times++) {
-            int observableCount = 10;
+            int observableCount = 100;
             // Test maxConcurrent from 2 to 12
             int maxConcurrent = 2 + (times % 10);
             AtomicInteger subscriptionCount = new AtomicInteger(0);
@@ -75,7 +75,7 @@ public void testMaxConcurrent() {
             for (int i = 0; i < observableCount; i++) {
                 SubscriptionCheckObservable sco = new SubscriptionCheckObservable(subscriptionCount, maxConcurrent);
                 scos.add(sco);
-                os.add(Observable.create(sco).subscribeOn(Schedulers.computation()));
+                os.add(Observable.create(sco));
             }
 
             Iterator iter = Observable.merge(os, maxConcurrent).toBlockingObservable().toIterable().iterator();
@@ -83,6 +83,7 @@ public void testMaxConcurrent() {
             while (iter.hasNext()) {
                 actual.add(iter.next());
             }
+            //            System.out.println("actual: " + actual);
             assertEquals(5 * observableCount, actual.size());
             for (SubscriptionCheckObservable sco : scos) {
                 assertFalse(sco.failed);
@@ -90,33 +91,39 @@ public void testMaxConcurrent() {
         }
     }
 
-    private static class SubscriptionCheckObservable implements
-            Observable.OnSubscribeFunc {
+    private static class SubscriptionCheckObservable implements Observable.OnSubscribeFunc {
 
         private final AtomicInteger subscriptionCount;
         private final int maxConcurrent;
         volatile boolean failed = false;
 
-        SubscriptionCheckObservable(AtomicInteger subscriptionCount,
-                int maxConcurrent) {
+        SubscriptionCheckObservable(AtomicInteger subscriptionCount, int maxConcurrent) {
             this.subscriptionCount = subscriptionCount;
             this.maxConcurrent = maxConcurrent;
         }
 
         @Override
-        public Subscription onSubscribe(Observer t1) {
-            if (subscriptionCount.incrementAndGet() > maxConcurrent) {
-                failed = true;
-            }
-            t1.onNext("one");
-            t1.onNext("two");
-            t1.onNext("three");
-            t1.onNext("four");
-            t1.onNext("five");
-            // We could not decrement subscriptionCount in the unsubscribe method
-            // as "unsubscribe" is not guaranteed to be called before the next "subscribe".
-            subscriptionCount.decrementAndGet();
-            t1.onCompleted();
+        public Subscription onSubscribe(final Observer t1) {
+            new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    if (subscriptionCount.incrementAndGet() > maxConcurrent) {
+                        failed = true;
+                    }
+                    t1.onNext("one");
+                    t1.onNext("two");
+                    t1.onNext("three");
+                    t1.onNext("four");
+                    t1.onNext("five");
+                    // We could not decrement subscriptionCount in the unsubscribe method
+                    // as "unsubscribe" is not guaranteed to be called before the next "subscribe".
+                    subscriptionCount.decrementAndGet();
+                    t1.onCompleted();
+                }
+
+            }).start();
+
             return Subscriptions.empty();
         }
 

From 290b3afc5eaab659ab701acfeda4c1e5fc53f960 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:07:19 -0800
Subject: [PATCH 365/441] InterruptibleBlockingQueue.size()

---
 .../rx/util/InterruptibleBlockingQueue.java   | 23 ++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java b/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
index 5083d6c153..df976a138f 100644
--- a/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
+++ b/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
@@ -3,6 +3,14 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicLong;
 
+/**
+ * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
+ * 
+ * This supports an interrupt() being called externally rather than needing to interrupt the thread. This allows
+ * unsubscribe behavior when this queue is being used.
+ * 
+ * @param 
+ */
 public class InterruptibleBlockingQueue {
 
     private final Semaphore semaphore;
@@ -20,7 +28,7 @@ public InterruptibleBlockingQueue(final int size) {
         this.semaphore = new Semaphore(size);
         this.capacity = size;
         this.mask = size - 1;
-        buffer = (E[])new Object[size];
+        buffer = (E[]) new Object[size];
     }
 
     /**
@@ -87,4 +95,17 @@ public E poll() {
         return v;
     }
 
+    public int size()
+    {
+        int size;
+        do
+        {
+            final long currentHead = head.get();
+            final long currentTail = tail.get();
+            size = (int) (currentTail - currentHead);
+        } while (size > buffer.length);
+
+        return size;
+    }
+
 }

From ffed4300a7f7ca56f5cc3fd1b5986e4f6d121cb3 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:41:43 -0800
Subject: [PATCH 366/441] More Parallal Unit Tests

- stressing it further while hunting down non-determism
---
 .../rx/operators/OperatorParallelTest.java    | 54 +++++++++++++++++--
 1 file changed, 51 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
index fe72a088e4..c8a114ba82 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.*;
 
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
@@ -31,6 +32,7 @@ public class OperatorParallelTest {
     public void testParallel() {
         int NUM = 1000;
         final AtomicInteger count = new AtomicInteger();
+        final AtomicInteger innerCount = new AtomicInteger();
         Observable.range(1, NUM).parallel(
                 new Func1, Observable>() {
 
@@ -40,17 +42,63 @@ public Observable call(Observable o) {
 
                             @Override
                             public Integer[] call(Integer t) {
+                                try {
+                                    // randomize to try and force non-determinism
+                                    // if we see these tests fail randomly then we have a problem with merging it all back together
+                                    Thread.sleep((int) (Math.random() * 10));
+                                } catch (InterruptedException e) {
+                                    System.out.println("*********** error!!!!!!!");
+                                    e.printStackTrace();
+                                    // TODO why is this exception not being thrown?
+                                    throw new RuntimeException(e);
+                                }
+                                //                                System.out.println("V: " + t  + " Thread: " + Thread.currentThread());
+                                innerCount.incrementAndGet();
                                 return new Integer[] { t, t * 99 };
                             }
 
                         });
                     }
-                }).toBlockingObservable().forEach(new Action1() {
+                })
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer[] v) {
+                        count.incrementAndGet();
+                        //                System.out.println("V: " + v[0] + " R: " + v[1] + " Thread: " + Thread.currentThread());
+                    }
+
+                });
+        System.out.println("parallel test completed ----------");
+
+        // just making sure we finish and get the number we expect
+        assertEquals("innerCount", NUM, innerCount.get());
+        assertEquals("finalCount", NUM, count.get());
+    }
+
+    @Test
+    public void testParallelWithNestedAsyncWork() {
+        int NUM = 20;
+        final AtomicInteger count = new AtomicInteger();
+        Observable.range(1, NUM).parallel(
+                new Func1, Observable>() {
+
+                    @Override
+                    public Observable call(Observable o) {
+                        return o.flatMap(new Func1>() {
+
+                            @Override
+                            public Observable call(Integer t) {
+                                return Observable.from(String.valueOf(t)).delay(100, TimeUnit.MILLISECONDS);
+                            }
+
+                        });
+                    }
+                }).toBlockingObservable().forEach(new Action1() {
 
             @Override
-            public void call(Integer[] v) {
+            public void call(String v) {
                 count.incrementAndGet();
-                System.out.println("V: " + v[0] + " R: " + v[1] + " Thread: " + Thread.currentThread());
             }
 
         });

From da1245c9005e9882a85c6161d999ed299dabccf6 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:42:02 -0800
Subject: [PATCH 367/441] Further TestSubscriber Functionality

---
 .../java/rx/observers/TestSubscriber.java     | 30 +++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index 2eb28a767d..ff875b2655 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -16,6 +16,8 @@
 package rx.observers;
 
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 import rx.Notification;
 import rx.Observer;
@@ -27,22 +29,25 @@
 public class TestSubscriber extends Subscriber {
 
     private final TestObserver testObserver;
+    private final CountDownLatch latch = new CountDownLatch(1);
+    private volatile Thread lastSeenThread;
 
     public TestSubscriber(Subscriber delegate) {
         this.testObserver = new TestObserver(delegate);
     }
-    
+
     public TestSubscriber(Observer delegate) {
         this.testObserver = new TestObserver(delegate);
     }
 
     public TestSubscriber() {
-        this.testObserver = new TestObserver(Subscribers.empty());
+        this.testObserver = new TestObserver(Subscribers. empty());
     }
 
     @Override
     public void onCompleted() {
         testObserver.onCompleted();
+        latch.countDown();
     }
 
     public List> getOnCompletedEvents() {
@@ -52,6 +57,7 @@ public List> getOnCompletedEvents() {
     @Override
     public void onError(Throwable e) {
         testObserver.onError(e);
+        latch.countDown();
     }
 
     public List getOnErrorEvents() {
@@ -60,6 +66,7 @@ public List getOnErrorEvents() {
 
     @Override
     public void onNext(T t) {
+        lastSeenThread = Thread.currentThread();
         testObserver.onNext(t);
     }
 
@@ -78,4 +85,23 @@ public void assertTerminalEvent() {
         testObserver.assertTerminalEvent();
     }
 
+    public void awaitTerminalEvent() {
+        try {
+            latch.await();
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted", e);
+        }
+    }
+
+    public void awaitTerminalEvent(long timeout, TimeUnit unit) {
+        try {
+            latch.await(timeout, unit);
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted", e);
+        }
+    }
+
+    public Thread getLastSeenThread() {
+        return lastSeenThread;
+    }
 }

From c90e51b29f126c4a363510aff3a922be1c2f7907 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:42:52 -0800
Subject: [PATCH 368/441] Remove Stray Println

---
 rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index c5142ebaea..fef13f5b12 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -135,7 +135,6 @@ public void onNext(T t) {
 
             private void completeInner() {
                 if (completionCounter.decrementAndGet() == 0 && (completed.get() || childObserver.isUnsubscribed())) {
-                    System.out.println("groupBy INNER completed");
                     if (childObserver.isUnsubscribed()) {
                         // if the entire groupBy has been unsubscribed and children are completed we will propagate the unsubscribe up.
                         unsubscribe();

From 0ab38b4dc6a392d52f42e7b3f851183b25ea572d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 10 Feb 2014 23:46:25 -0800
Subject: [PATCH 369/441] Comment Out "Time Gap" Tests on GroupBy

See https://github.com/Netflix/RxJava/issues/844
---
 .../src/test/java/rx/operators/OperatorGroupByTest.java       | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 2fe8130caf..7fc1207208 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -28,6 +28,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 import rx.Observable;
@@ -252,6 +253,7 @@ public void testUnsubscribeOnNestedTakeAndSyncInfiniteStream() throws Interrupte
     /*
      * We will only take 1 group with 20 events from it and then unsubscribe.
      */
+    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testUnsubscribeOnNestedTakeAndAsyncInfiniteStream() throws InterruptedException {
         final AtomicInteger subscribeCounter = new AtomicInteger();
@@ -646,6 +648,7 @@ public void call(String s) {
         assertEquals(6, results.size());
     }
 
+    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
@@ -800,6 +803,7 @@ public void call(String s) {
         assertEquals(6, results.size());
     }
 
+    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
         final ArrayList results = new ArrayList();

From 356a6902a6e96e4d1a131d71521b62d26596fd6c Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Tue, 11 Feb 2014 13:17:26 +0800
Subject: [PATCH 370/441] Add timeout unit tests

---
 .../src/test/java/rx/TimeoutTests.java        |  52 ++++-
 .../rx/operators/OperationTimeoutTest.java    | 184 +++++++++++++++++-
 2 files changed, 232 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/TimeoutTests.java b/rxjava-core/src/test/java/rx/TimeoutTests.java
index 2e1bf6412e..0934d197b2 100644
--- a/rxjava-core/src/test/java/rx/TimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/TimeoutTests.java
@@ -15,9 +15,15 @@
  */
 package rx;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
@@ -26,6 +32,7 @@
 import org.mockito.InOrder;
 import org.mockito.MockitoAnnotations;
 
+import rx.Observable.OnSubscribe;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -219,4 +226,45 @@ public void shouldSwitchToOtherAndCanBeUnsubscribedIfOnNextNotWithinTimeout() {
         inOrder.verify(observer, times(1)).onNext("b");
         inOrder.verifyNoMoreInteractions();
     }
+
+    @Test
+    public void shouldTimeoutIfSynchronizedObservableEmitFirstOnNextNotWithinTimeout()
+            throws InterruptedException {
+        final CountDownLatch exit = new CountDownLatch(1);
+        final CountDownLatch timeoutSetuped = new CountDownLatch(1);
+
+        @SuppressWarnings("unchecked")
+        final Observer observer = mock(Observer.class);
+        new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribe() {
+
+                    @Override
+                    public void call(Subscriber subscriber) {
+                        try {
+                            timeoutSetuped.countDown();
+                            exit.await();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                        subscriber.onNext("a");
+                        subscriber.onCompleted();
+                    }
+
+                }).timeout(1, TimeUnit.SECONDS, testScheduler)
+                        .subscribe(observer);
+            }
+        }).start();
+
+        timeoutSetuped.await();
+        testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(isA(TimeoutException.class));
+        inOrder.verifyNoMoreInteractions();
+
+        exit.countDown(); // exit the thread
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
index 8644127110..ab22e20993 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
@@ -15,17 +15,32 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeoutException;
 
 import org.junit.Test;
 import org.mockito.InOrder;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
+import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
@@ -239,4 +254,169 @@ public Observable call() {
         verify(o, never()).onCompleted();
 
     }
+
+    @Test
+    public void testTimeoutSelectorWithFirstTimeoutFirstAndNoOtherObservable() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return timeout;
+            }
+        };
+
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return PublishSubject.create();
+            }
+        };
+
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        source.timeout(firstTimeoutFunc, timeoutFunc).subscribe(o);
+
+        timeout.onNext(1);
+
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onError(isA(TimeoutException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testTimeoutSelectorWithTimeoutFirstAndNoOtherObservable() {
+        PublishSubject source = PublishSubject.create();
+        final PublishSubject timeout = PublishSubject.create();
+
+        Func0> firstTimeoutFunc = new Func0>() {
+            @Override
+            public Observable call() {
+                return PublishSubject.create();
+            }
+        };
+
+        Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                return timeout;
+            }
+        };
+
+        @SuppressWarnings("unchecked")
+        Observer o = mock(Observer.class);
+        source.timeout(firstTimeoutFunc, timeoutFunc).subscribe(o);
+        source.onNext(1);
+
+        timeout.onNext(1);
+
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onError(isA(TimeoutException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testTimeoutSelectorWithTimeoutAndOnNextRaceCondition() throws InterruptedException {
+        // Thread 1                                    Thread 2
+        //
+        // observer.onNext(1)
+        // start timeout
+        // unsubscribe timeout in thread 2          start to do some long-time work in "unsubscribe"
+        // observer.onNext(2)
+        // timeout.onNext(1)
+        //                                          "unsubscribe" done
+        //
+        //
+        // In the above case, the timeout operator should ignore "timeout.onNext(1)"
+        // since "observer" has already seen 2.
+        final CountDownLatch observerReceivedTwo = new CountDownLatch(1);
+        final CountDownLatch timeoutEmittedOne = new CountDownLatch(1);
+        final CountDownLatch observerCompleted = new CountDownLatch(1);
+
+        final Func1> timeoutFunc = new Func1>() {
+            @Override
+            public Observable call(Integer t1) {
+                if (t1 == 1) {
+                    // Force "unsubscribe" run on another thread
+                    return Observable.create(new OnSubscribe(){
+                        @Override
+                        public void call(Subscriber subscriber) {
+                            subscriber.add(Subscriptions.create(new Action0(){
+                                @Override
+                                public void call() {
+                                    try {
+                                        // emulate "unsubscribe" is busy and finishes after timeout.onNext(1)
+                                        timeoutEmittedOne.await();
+                                    } catch (InterruptedException e) {
+                                        e.printStackTrace();
+                                    }
+                                }}));
+                            // force the timeout message be sent after observer.onNext(2)
+                            try {
+                                observerReceivedTwo.await();
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                            }
+                            if(!subscriber.isUnsubscribed()) {
+                                subscriber.onNext(1);
+                                timeoutEmittedOne.countDown();
+                            }
+                        }
+                    }).subscribeOn(Schedulers.newThread());
+                } else {
+                    return PublishSubject.create();
+                }
+            }
+        };
+
+        @SuppressWarnings("unchecked")
+        final Observer o = mock(Observer.class);
+        doAnswer(new Answer() {
+
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                observerReceivedTwo.countDown();
+                return null;
+            }
+
+        }).when(o).onNext(2);
+        doAnswer(new Answer() {
+
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                observerCompleted.countDown();
+                return null;
+            }
+
+        }).when(o).onCompleted();
+
+        new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                PublishSubject source = PublishSubject.create();
+                source.timeout(timeoutFunc, Observable.from(3)).subscribe(o);
+                source.onNext(1); // start timeout
+                source.onNext(2); // disable timeout
+                try {
+                    timeoutEmittedOne.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                source.onCompleted();
+            }
+
+        }).start();
+
+        observerCompleted.await();
+
+        InOrder inOrder = inOrder(o);
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o, never()).onNext(3);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
 }

From ddca23b34997ea9fb77d2c7615b7bd581bfca745 Mon Sep 17 00:00:00 2001
From: Acardiac 
Date: Tue, 11 Feb 2014 12:33:30 +0100
Subject: [PATCH 371/441] Add 'Fragment-Host' to rxjava-contrib modules for
 OSGi

---
 rxjava-contrib/rxjava-android/build.gradle                 | 1 +
 rxjava-contrib/rxjava-apache-http/build.gradle             | 1 +
 rxjava-contrib/rxjava-async-util/build.gradle              | 1 +
 rxjava-contrib/rxjava-computation-expressions/build.gradle | 1 +
 rxjava-contrib/rxjava-string/build.gradle                  | 1 +
 rxjava-contrib/rxjava-swing/build.gradle                   | 1 +
 6 files changed, 6 insertions(+)

diff --git a/rxjava-contrib/rxjava-android/build.gradle b/rxjava-contrib/rxjava-android/build.gradle
index 7f50fa5858..d3bc3e2e8d 100644
--- a/rxjava-contrib/rxjava-android/build.gradle
+++ b/rxjava-contrib/rxjava-android/build.gradle
@@ -27,6 +27,7 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
 
diff --git a/rxjava-contrib/rxjava-apache-http/build.gradle b/rxjava-contrib/rxjava-apache-http/build.gradle
index 81d150ccc3..c93f831374 100644
--- a/rxjava-contrib/rxjava-apache-http/build.gradle
+++ b/rxjava-contrib/rxjava-apache-http/build.gradle
@@ -16,5 +16,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
diff --git a/rxjava-contrib/rxjava-async-util/build.gradle b/rxjava-contrib/rxjava-async-util/build.gradle
index 09d9aae655..7acd6a856d 100644
--- a/rxjava-contrib/rxjava-async-util/build.gradle
+++ b/rxjava-contrib/rxjava-async-util/build.gradle
@@ -16,5 +16,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
diff --git a/rxjava-contrib/rxjava-computation-expressions/build.gradle b/rxjava-contrib/rxjava-computation-expressions/build.gradle
index 21bc395344..049cf185d4 100644
--- a/rxjava-contrib/rxjava-computation-expressions/build.gradle
+++ b/rxjava-contrib/rxjava-computation-expressions/build.gradle
@@ -16,5 +16,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
diff --git a/rxjava-contrib/rxjava-string/build.gradle b/rxjava-contrib/rxjava-string/build.gradle
index 5c578ae04d..a3423a5173 100644
--- a/rxjava-contrib/rxjava-string/build.gradle
+++ b/rxjava-contrib/rxjava-string/build.gradle
@@ -26,5 +26,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }
diff --git a/rxjava-contrib/rxjava-swing/build.gradle b/rxjava-contrib/rxjava-swing/build.gradle
index ea863813a2..87c04c3b53 100644
--- a/rxjava-contrib/rxjava-swing/build.gradle
+++ b/rxjava-contrib/rxjava-swing/build.gradle
@@ -25,5 +25,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }

From d947c408f26335426c47ee1b1ac96afe65256a01 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Tue, 11 Feb 2014 18:09:47 +0800
Subject: [PATCH 372/441] Reimplement the timeout operator and fix timeout bugs

---
 rxjava-core/src/main/java/rx/Observable.java  |  40 +--
 .../java/rx/operators/OperationTimeout.java   | 320 ------------------
 .../java/rx/operators/OperatorTimeout.java    |  65 ++++
 .../rx/operators/OperatorTimeoutBase.java     | 147 ++++++++
 .../OperatorTimeoutWithSelector.java          |  91 +++++
 .../rx/operators/OperationTimeoutTest.java    |   1 -
 6 files changed, 319 insertions(+), 345 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTimeout.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index b3e8273960..61f48602ea 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -87,7 +87,6 @@
 import rx.operators.OperationTakeWhile;
 import rx.operators.OperationThrottleFirst;
 import rx.operators.OperationTimeInterval;
-import rx.operators.OperationTimeout;
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
 import rx.operators.OperationToMultimap;
@@ -105,6 +104,8 @@
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
+import rx.operators.OperatorTimeout;
+import rx.operators.OperatorTimeoutWithSelector;
 import rx.operators.OperatorTimestamp;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
@@ -7754,11 +7755,8 @@ public final Observable> timeInterval(Scheduler scheduler) {
      * @return an Observable that completes if either the first item or any subsequent item doesn't
      *         arrive within the time windows specified by the timeout selectors
      */
-    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
-        if (firstTimeoutSelector == null) {
-            throw new NullPointerException("firstTimeoutSelector");
-        }
-        return timeout(firstTimeoutSelector, timeoutSelector, Observable. empty());
+    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
+        return timeout(firstTimeoutSelector, timeoutSelector, null);
     }
 
     /**
@@ -7784,14 +7782,11 @@ public final  Observable timeout(Func0> firstTi
      * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if either the first item emitted by the source Observable or any
      *         subsequent item don't arrive within time windows defined by the timeout selectors
      */
-    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
-        if (firstTimeoutSelector == null) {
-            throw new NullPointerException("firstTimeoutSelector");
-        }
-        if (other == null) {
-            throw new NullPointerException("other");
+    public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
+        if(timeoutSelector == null) {
+            throw new NullPointerException("timeoutSelector is null");
         }
-        return create(OperationTimeout.timeoutSelector(this, firstTimeoutSelector, timeoutSelector, other));
+        return lift(new OperatorTimeoutWithSelector(firstTimeoutSelector, timeoutSelector, other));
     }
 
     /**
@@ -7813,8 +7808,8 @@ public final  Observable timeout(Func0> firstTi
      *         the source Observable takes longer to arrive than the time window defined by the
      *         selector for the previously emitted item
      */
-    public final  Observable timeout(Func1> timeoutSelector) {
-        return timeout(timeoutSelector, Observable. empty());
+    public final  Observable timeout(Func1> timeoutSelector) {
+        return timeout(null, timeoutSelector, null);
     }
 
     /**
@@ -7838,11 +7833,8 @@ public final  Observable timeout(Func1>
      *         fallback Observable if a item emitted by the source Observable takes longer to arrive
      *         than the time window defined by the selector for the previously emitted item
      */
-    public final  Observable timeout(Func1> timeoutSelector, Observable other) {
-        if (other == null) {
-            throw new NullPointerException("other");
-        }
-        return create(OperationTimeout.timeoutSelector(this, null, timeoutSelector, other));
+    public final  Observable timeout(Func1> timeoutSelector, Observable other) {
+        return timeout(null, timeoutSelector, other);
     }
 
     /**
@@ -7863,7 +7855,7 @@ public final  Observable timeout(Func1>
      * @see MSDN: Observable.Timeout
      */
     public final Observable timeout(long timeout, TimeUnit timeUnit) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit));
+        return timeout(timeout, timeUnit, null, Schedulers.computation());
     }
 
     /**
@@ -7886,7 +7878,7 @@ public final Observable timeout(long timeout, TimeUnit timeUnit) {
      * @see MSDN: Observable.Timeout
      */
     public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, other));
+        return timeout(timeout, timeUnit, other, Schedulers.computation());
     }
 
     /**
@@ -7911,7 +7903,7 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, ObservableMSDN: Observable.Timeout
      */
     public final Observable timeout(long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, other, scheduler));
+        return lift(new OperatorTimeout(timeout, timeUnit, other, scheduler));
     }
 
     /**
@@ -7934,7 +7926,7 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, ObservableMSDN: Observable.Timeout
      */
     public final Observable timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
-        return create(OperationTimeout.timeout(this, timeout, timeUnit, scheduler));
+        return timeout(timeout, timeUnit, null, scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java b/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
deleted file mode 100644
index 224048788e..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeout.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/**
- * Copyright 2014 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 java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.schedulers.Schedulers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-
-/**
- * Applies a timeout policy for each element in the observable sequence, using
- * the specified scheduler to run timeout timers. If the next element isn't
- * received within the specified timeout duration starting from its predecessor,
- * the other observable sequence is used to produce future messages from that
- * point on.
- */
-public final class OperationTimeout {
-
-    public static  OnSubscribeFunc timeout(Observable source, long timeout, TimeUnit timeUnit) {
-        return new Timeout(source, timeout, timeUnit, null, Schedulers.computation());
-    }
-
-    public static  OnSubscribeFunc timeout(Observable sequence, long timeout, TimeUnit timeUnit, Observable other) {
-        return new Timeout(sequence, timeout, timeUnit, other, Schedulers.computation());
-    }
-
-    public static  OnSubscribeFunc timeout(Observable source, long timeout, TimeUnit timeUnit, Scheduler scheduler) {
-        return new Timeout(source, timeout, timeUnit, null, scheduler);
-    }
-
-    public static  OnSubscribeFunc timeout(Observable sequence, long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
-        return new Timeout(sequence, timeout, timeUnit, other, scheduler);
-    }
-
-    private static class Timeout implements Observable.OnSubscribeFunc {
-        private final Observable source;
-        private final long timeout;
-        private final TimeUnit timeUnit;
-        private final Scheduler scheduler;
-        private final Observable other;
-
-        private Timeout(Observable source, long timeout, TimeUnit timeUnit, Observable other, Scheduler scheduler) {
-            this.source = source;
-            this.timeout = timeout;
-            this.timeUnit = timeUnit;
-            this.other = other;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            final AtomicBoolean terminated = new AtomicBoolean(false);
-            final AtomicLong actual = new AtomicLong(0L);  // Required to handle race between onNext and timeout
-            final SerialSubscription serial = new SerialSubscription();
-            final Object gate = new Object();
-            CompositeSubscription composite = new CompositeSubscription();
-            final Func0 schedule = new Func0() {
-                @Override
-                public Subscription call() {
-                    final long expected = actual.get();
-                    return scheduler.schedule(new Action1() {
-                        @Override
-                        public void call(Inner inner) {
-                            boolean timeoutWins = false;
-                            synchronized (gate) {
-                                if (expected == actual.get() && !terminated.getAndSet(true)) {
-                                    timeoutWins = true;
-                                }
-                            }
-                            if (timeoutWins) {
-                                if (other == null) {
-                                    observer.onError(new TimeoutException());
-                                }
-                                else {
-                                    serial.set(other.subscribe(observer));
-                                }
-                            }
-
-                        }
-                    }, timeout, timeUnit);
-                }
-            };
-            SafeObservableSubscription subscription = new SafeObservableSubscription();
-            composite.add(subscription.wrap(source.subscribe(new Observer() {
-                @Override
-                public void onNext(T value) {
-                    boolean onNextWins = false;
-                    synchronized (gate) {
-                        if (!terminated.get()) {
-                            actual.incrementAndGet();
-                            onNextWins = true;
-                        }
-                    }
-                    if (onNextWins) {
-                        serial.setSubscription(schedule.call());
-                        observer.onNext(value);
-                    }
-                }
-
-                @Override
-                public void onError(Throwable error) {
-                    boolean onErrorWins = false;
-                    synchronized (gate) {
-                        if (!terminated.getAndSet(true)) {
-                            onErrorWins = true;
-                        }
-                    }
-                    if (onErrorWins) {
-                        serial.unsubscribe();
-                        observer.onError(error);
-                    }
-                }
-
-                @Override
-                public void onCompleted() {
-                    boolean onCompletedWins = false;
-                    synchronized (gate) {
-                        if (!terminated.getAndSet(true)) {
-                            onCompletedWins = true;
-                        }
-                    }
-                    if (onCompletedWins) {
-                        serial.unsubscribe();
-                        observer.onCompleted();
-                    }
-                }
-            })));
-            composite.add(serial);
-            serial.setSubscription(schedule.call());
-            return composite;
-        }
-    }
-
-    /** Timeout using a per-item observable sequence. */
-    public static  OnSubscribeFunc timeoutSelector(Observable source, Func0> firstValueTimeout, Func1> valueTimeout, Observable other) {
-        return new TimeoutSelector(source, firstValueTimeout, valueTimeout, other);
-    }
-
-    /** Timeout using a per-item observable sequence. */
-    private static final class TimeoutSelector implements OnSubscribeFunc {
-        final Observable source;
-        final Func0> firstValueTimeout;
-        final Func1> valueTimeout;
-        final Observable other;
-
-        public TimeoutSelector(Observable source, Func0> firstValueTimeout, Func1> valueTimeout, Observable other) {
-            this.source = source;
-            this.firstValueTimeout = firstValueTimeout;
-            this.valueTimeout = valueTimeout;
-            this.other = other;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            SourceObserver so = new SourceObserver(t1, valueTimeout, other, csub);
-            if (firstValueTimeout != null) {
-                Observable o;
-                try {
-                    o = firstValueTimeout.call();
-                } catch (Throwable t) {
-                    t1.onError(t);
-                    return Subscriptions.empty();
-                }
-
-                csub.add(o.subscribe(new TimeoutObserver(so)));
-            }
-            csub.add(source.subscribe(so));
-            return csub;
-        }
-
-        /** Observe the source. */
-        private static final class SourceObserver implements Observer, TimeoutCallback {
-            final Observer observer;
-            final Func1> valueTimeout;
-            final Observable other;
-            final CompositeSubscription cancel;
-            final Object guard;
-            boolean done;
-            final SerialSubscription tsub;
-            final TimeoutObserver to;
-
-            public SourceObserver(Observer observer, Func1> valueTimeout, Observable other, CompositeSubscription cancel) {
-                this.observer = observer;
-                this.valueTimeout = valueTimeout;
-                this.other = other;
-                this.cancel = cancel;
-                this.guard = new Object();
-                this.tsub = new SerialSubscription();
-                this.cancel.add(tsub);
-                this.to = new TimeoutObserver(this);
-            }
-
-            @Override
-            public void onNext(T args) {
-                tsub.set(Subscriptions.empty());
-
-                synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
-                    observer.onNext(args);
-                }
-
-                Observable o;
-                try {
-                    o = valueTimeout.call(args);
-                } catch (Throwable t) {
-                    onError(t);
-                    return;
-                }
-
-                SerialSubscription osub = new SerialSubscription();
-                tsub.set(osub);
-
-                osub.set(o.subscribe(to));
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
-                    done = true;
-                    observer.onError(e);
-                }
-                cancel.unsubscribe();
-            }
-
-            @Override
-            public void onCompleted() {
-                synchronized (guard) {
-                    if (done) {
-                        return;
-                    }
-                    done = true;
-                    observer.onCompleted();
-                }
-                cancel.unsubscribe();
-            }
-
-            @Override
-            public void timeout() {
-                if (other != null) {
-                    synchronized (guard) {
-                        if (done) {
-                            return;
-                        }
-                        done = true;
-                    }
-                    cancel.clear();
-                    cancel.add(other.subscribe(observer));
-                } else {
-                    onCompleted();
-                }
-            }
-        }
-
-        /** The timeout callback. */
-        private interface TimeoutCallback {
-            void timeout();
-
-            void onError(Throwable t);
-        }
-
-        /** Observe the timeout. */
-        private static final class TimeoutObserver implements Observer {
-            final TimeoutCallback parent;
-
-            public TimeoutObserver(TimeoutCallback parent) {
-                this.parent = parent;
-            }
-
-            @Override
-            public void onNext(V args) {
-                parent.timeout();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                parent.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                parent.timeout();
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
new file mode 100644
index 0000000000..7a1c0cf835
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
@@ -0,0 +1,65 @@
+/**
+ * Copyright 2014 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 java.util.concurrent.TimeUnit;
+
+import rx.Observable;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscription;
+import rx.util.functions.Action1;
+
+/**
+ * Applies a timeout policy for each element in the observable sequence, using
+ * the specified scheduler to run timeout timers. If the next element isn't
+ * received within the specified timeout duration starting from its predecessor,
+ * the other observable sequence is used to produce future messages from that
+ * point on.
+ */
+public final class OperatorTimeout extends OperatorTimeoutBase {
+
+    public OperatorTimeout(final long timeout, final TimeUnit timeUnit,
+            Observable other, final Scheduler scheduler) {
+        super(new FirstTimeoutStub() {
+
+            @Override
+            public Subscription call(
+                    final TimeoutSubscriber timeoutSubscriber,
+                    final Long seqId) {
+                return scheduler.schedule(new Action1() {
+                    @Override
+                    public void call(Inner inner) {
+                        timeoutSubscriber.onTimeout(seqId);
+                    }
+                }, timeout, timeUnit);
+            }
+        }, new TimeoutStub() {
+
+            @Override
+            public Subscription call(
+                    final TimeoutSubscriber timeoutSubscriber,
+                    final Long seqId, T value) {
+                return scheduler.schedule(new Action1() {
+                    @Override
+                    public void call(Inner inner) {
+                        timeoutSubscriber.onTimeout(seqId);
+                    }
+                }, timeout, timeUnit);
+            }
+        }, other);
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
new file mode 100644
index 0000000000..fc19020cef
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -0,0 +1,147 @@
+package rx.operators;
+
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observers.SynchronizedSubscriber;
+import rx.subscriptions.SerialSubscription;
+import rx.util.functions.Func2;
+import rx.util.functions.Func3;
+
+class OperatorTimeoutBase implements Operator {
+
+    /**
+     * Set up the timeout action on the first value.
+     * 
+     * @param 
+     */
+    /* package-private */static interface FirstTimeoutStub extends
+            Func2, Long, Subscription> {
+    }
+
+    /**
+     * Set up the timeout action based on every value
+     * 
+     * @param 
+     */
+    /* package-private */static interface TimeoutStub extends
+            Func3, Long, T, Subscription> {
+    }
+
+    private final FirstTimeoutStub firstTimeoutStub;
+    private final TimeoutStub timeoutStub;
+    private final Observable other;
+
+    /* package-private */OperatorTimeoutBase(
+            FirstTimeoutStub firstTimeoutStub, TimeoutStub timeoutStub,
+            Observable other) {
+        this.firstTimeoutStub = firstTimeoutStub;
+        this.timeoutStub = timeoutStub;
+        this.other = other;
+    }
+
+    @Override
+    public Subscriber call(Subscriber subscriber) {
+        final SerialSubscription serial = new SerialSubscription();
+        subscriber.add(serial);
+        // Use SynchronizedSubscriber for safe memory access
+        // as the subscriber will be accessed in the current thread or the
+        // scheduler or other Observables.
+        final SynchronizedSubscriber synchronizedSubscriber = new SynchronizedSubscriber(
+                subscriber);
+
+        TimeoutSubscriber timeoutSubscriber = new TimeoutSubscriber(
+                synchronizedSubscriber, timeoutStub, serial, other);
+        serial.set(firstTimeoutStub.call(timeoutSubscriber, 0L));
+        return timeoutSubscriber;
+    }
+
+    /* package-private */static class TimeoutSubscriber extends
+            Subscriber {
+
+        private final AtomicBoolean terminated = new AtomicBoolean(false);
+        private final AtomicLong actual = new AtomicLong(0L);
+        private final SerialSubscription serial;
+        private final Object gate = new Object();
+
+        private final SynchronizedSubscriber synchronizedSubscriber;
+
+        private final TimeoutStub timeoutStub;
+
+        private final Observable other;
+
+        private TimeoutSubscriber(
+                SynchronizedSubscriber synchronizedSubscriber,
+                TimeoutStub timeoutStub, SerialSubscription serial,
+                Observable other) {
+            this.synchronizedSubscriber = synchronizedSubscriber;
+            this.timeoutStub = timeoutStub;
+            this.serial = serial;
+            this.other = other;
+        }
+
+        @Override
+        public void onNext(T value) {
+            boolean onNextWins = false;
+            synchronized (gate) {
+                if (!terminated.get()) {
+                    actual.incrementAndGet();
+                    onNextWins = true;
+                }
+            }
+            if (onNextWins) {
+                synchronizedSubscriber.onNext(value);
+                serial.set(timeoutStub.call(this, actual.get(), value));
+            }
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            boolean onErrorWins = false;
+            synchronized (gate) {
+                if (!terminated.getAndSet(true)) {
+                    onErrorWins = true;
+                }
+            }
+            if (onErrorWins) {
+                serial.unsubscribe();
+                synchronizedSubscriber.onError(error);
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            boolean onCompletedWins = false;
+            synchronized (gate) {
+                if (!terminated.getAndSet(true)) {
+                    onCompletedWins = true;
+                }
+            }
+            if (onCompletedWins) {
+                serial.unsubscribe();
+                synchronizedSubscriber.onCompleted();
+            }
+        }
+
+        public void onTimeout(long seqId) {
+            long expected = seqId;
+            boolean timeoutWins = false;
+            synchronized (gate) {
+                if (expected == actual.get() && !terminated.getAndSet(true)) {
+                    timeoutWins = true;
+                }
+            }
+            if (timeoutWins) {
+                if (other == null) {
+                    synchronizedSubscriber.onError(new TimeoutException());
+                } else {
+                    serial.set(other.subscribe(synchronizedSubscriber));
+                }
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
new file mode 100644
index 0000000000..6f248eddd1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -0,0 +1,91 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.Exceptions;
+import rx.util.functions.Func0;
+import rx.util.functions.Func1;
+
+public class OperatorTimeoutWithSelector extends
+        OperatorTimeoutBase {
+
+    public OperatorTimeoutWithSelector(
+            final Func0> firstTimeoutSelector,
+            final Func1> timeoutSelector,
+            Observable other) {
+        super(new FirstTimeoutStub() {
+
+            @Override
+            public Subscription call(
+                    final TimeoutSubscriber timeoutSubscriber,
+                    final Long seqId) {
+                if (firstTimeoutSelector != null) {
+                    Observable o = null;
+                    try {
+                        o = firstTimeoutSelector.call();
+                    } catch (Throwable t) {
+                        Exceptions.throwIfFatal(t);
+                        timeoutSubscriber.onError(t);
+                        return Subscriptions.empty();
+                    }
+                    return o.subscribe(new Subscriber() {
+
+                        @Override
+                        public void onCompleted() {
+                            timeoutSubscriber.onTimeout(seqId);
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            timeoutSubscriber.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(U t) {
+                            timeoutSubscriber.onTimeout(seqId);
+                        }
+
+                    });
+                } else {
+                    return Subscriptions.empty();
+                }
+            }
+        }, new TimeoutStub() {
+
+            @Override
+            public Subscription call(
+                    final TimeoutSubscriber timeoutSubscriber,
+                    final Long seqId, T value) {
+                Observable o = null;
+                try {
+                    o = timeoutSelector.call(value);
+                } catch (Throwable t) {
+                    Exceptions.throwIfFatal(t);
+                    timeoutSubscriber.onError(t);
+                    return Subscriptions.empty();
+                }
+                return o.subscribe(new Subscriber() {
+
+                    @Override
+                    public void onCompleted() {
+                        timeoutSubscriber.onTimeout(seqId);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        timeoutSubscriber.onError(e);
+                    }
+
+                    @Override
+                    public void onNext(V t) {
+                        timeoutSubscriber.onTimeout(seqId);
+                    }
+
+                });
+            }
+        }, other);
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
index ab22e20993..9dff4d6c13 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
@@ -16,7 +16,6 @@
 package rx.operators;
 
 import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.isA;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;

From 290319aca8a99c119016688a4925fe48ab1e1925 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Tue, 11 Feb 2014 21:31:24 +0800
Subject: [PATCH 373/441] Rename the files

---
 .../OperatorTimeoutTests.java}                            | 8 ++++++--
 ...eoutTest.java => OperatorTimeoutWithSelectorTest.java} | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)
 rename rxjava-core/src/test/java/rx/{TimeoutTests.java => operators/OperatorTimeoutTests.java} (98%)
 rename rxjava-core/src/test/java/rx/operators/{OperationTimeoutTest.java => OperatorTimeoutWithSelectorTest.java} (99%)

diff --git a/rxjava-core/src/test/java/rx/TimeoutTests.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/TimeoutTests.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
index 0934d197b2..11791cd4fb 100644
--- a/rxjava-core/src/test/java/rx/TimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx;
+package rx.operators;
 
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.isA;
@@ -32,11 +32,15 @@
 import org.mockito.InOrder;
 import org.mockito.MockitoAnnotations;
 
+import rx.Observable;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
 import rx.Observable.OnSubscribe;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class TimeoutTests {
+public class OperatorTimeoutTests {
     private PublishSubject underlyingSubject;
     private TestScheduler testScheduler;
     private Observable withTimeout;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 9dff4d6c13..76d19b066e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeoutTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -43,7 +43,7 @@
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
-public class OperationTimeoutTest {
+public class OperatorTimeoutWithSelectorTest {
     @Test(timeout = 2000)
     public void testTimeoutSelectorNormal1() {
         PublishSubject source = PublishSubject.create();

From 8cf79d73792b17982238a7ef3318b20291acb70e Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Tue, 11 Feb 2014 21:33:40 +0800
Subject: [PATCH 374/441] Add the missing License

---
 .../java/rx/operators/OperatorTimeoutBase.java    | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index fc19020cef..71104c1782 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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 java.util.concurrent.TimeoutException;

From 6d3066fbacfa88364177b288dff51045af117c25 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 11 Feb 2014 12:53:25 -0800
Subject: [PATCH 375/441] Fix import org.apache.http.protocol.HttpContext;

---
 .../src/main/java/rx/apache/http/ObservableHttp.java            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
index 4ea4a591b2..6ea424848a 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttp.java
@@ -21,7 +21,7 @@
 import org.apache.http.nio.client.HttpAsyncClient;
 import org.apache.http.nio.client.methods.HttpAsyncMethods;
 import org.apache.http.nio.protocol.HttpAsyncRequestProducer;
-import org.apache.http.protocol.Http.HttpContext;
+import org.apache.http.protocol.HttpContext;
 import org.apache.http.protocol.BasicHttpContext;
 
 import rx.Observable;

From 5d1006ea07432e34f1ed4b2d75c0024fa8cdae78 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 11 Feb 2014 14:18:21 -0800
Subject: [PATCH 376/441] Move InterruptibleBlockingQueue Inside ObserveOn

I decided I'm not ready to commit to this in the public API so am leaving it an implementation detail of ObserveOn.
While working on groupBy, parallel and subscribeOn this queue was not the right solution.
---
 .../java/rx/operators/OperatorObserveOn.java  | 110 ++++++++++++++++-
 .../rx/util/InterruptibleBlockingQueue.java   | 111 ------------------
 2 files changed, 108 insertions(+), 113 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 79c38b56cf..02917e8ccb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
@@ -24,7 +25,6 @@
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.InterruptibleBlockingQueue;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
@@ -112,7 +112,7 @@ private class ObserveOnSubscriber extends Subscriber {
         final Subscriber observer;
         private volatile Scheduler.Inner recursiveScheduler;
 
-        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue(bufferSize);
+        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue(bufferSize);
         final AtomicLong counter = new AtomicLong(0);
 
         public ObserveOnSubscriber(Subscriber observer) {
@@ -220,4 +220,110 @@ private void pollQueue() {
 
     }
 
+    /**
+     * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
+     * 
+     * This supports an interrupt() being called externally rather than needing to interrupt the thread. This allows
+     * unsubscribe behavior when this queue is being used.
+     * 
+     * @param 
+     */
+    private static class InterruptibleBlockingQueue {
+
+        private final Semaphore semaphore;
+        private volatile boolean interrupted = false;
+
+        private final E[] buffer;
+
+        private AtomicLong tail = new AtomicLong();
+        private AtomicLong head = new AtomicLong();
+        private final int capacity;
+        private final int mask;
+
+        @SuppressWarnings("unchecked")
+        public InterruptibleBlockingQueue(final int size) {
+            this.semaphore = new Semaphore(size);
+            this.capacity = size;
+            this.mask = size - 1;
+            buffer = (E[]) new Object[size];
+        }
+
+        /**
+         * Used to unsubscribe and interrupt the producer if blocked in put()
+         */
+        public void interrupt() {
+            interrupted = true;
+            semaphore.release();
+        }
+
+        public void addBlocking(final E e) throws InterruptedException {
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            semaphore.acquire();
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            if (e == null) {
+                throw new IllegalArgumentException("Can not put null");
+            }
+
+            if (offer(e)) {
+                return;
+            } else {
+                throw new IllegalStateException("Queue is full");
+            }
+        }
+
+        private boolean offer(final E e) {
+            final long _t = tail.get();
+            if (_t - head.get() == capacity) {
+                // queue is full
+                return false;
+            }
+            int index = (int) (_t & mask);
+            buffer[index] = e;
+            // move the tail forward
+            tail.lazySet(_t + 1);
+
+            return true;
+        }
+
+        public E poll() {
+            if (interrupted) {
+                return null;
+            }
+            final long _h = head.get();
+            if (tail.get() == _h) {
+                // nothing available
+                return null;
+            }
+            int index = (int) (_h & mask);
+
+            // fetch the item
+            E v = buffer[index];
+            // allow GC to happen
+            buffer[index] = null;
+            // increment and signal we're done
+            head.lazySet(_h + 1);
+            if (v != null) {
+                semaphore.release();
+            }
+            return v;
+        }
+
+        public int size()
+        {
+            int size;
+            do
+            {
+                final long currentHead = head.get();
+                final long currentTail = tail.get();
+                size = (int) (currentTail - currentHead);
+            } while (size > buffer.length);
+
+            return size;
+        }
+
+    }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java b/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
deleted file mode 100644
index df976a138f..0000000000
--- a/rxjava-core/src/main/java/rx/util/InterruptibleBlockingQueue.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package rx.util;
-
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
- * 
- * This supports an interrupt() being called externally rather than needing to interrupt the thread. This allows
- * unsubscribe behavior when this queue is being used.
- * 
- * @param 
- */
-public class InterruptibleBlockingQueue {
-
-    private final Semaphore semaphore;
-    private volatile boolean interrupted = false;
-
-    private final E[] buffer;
-
-    private AtomicLong tail = new AtomicLong();
-    private AtomicLong head = new AtomicLong();
-    private final int capacity;
-    private final int mask;
-
-    @SuppressWarnings("unchecked")
-    public InterruptibleBlockingQueue(final int size) {
-        this.semaphore = new Semaphore(size);
-        this.capacity = size;
-        this.mask = size - 1;
-        buffer = (E[]) new Object[size];
-    }
-
-    /**
-     * Used to unsubscribe and interrupt the producer if blocked in put()
-     */
-    public void interrupt() {
-        interrupted = true;
-        semaphore.release();
-    }
-
-    public void addBlocking(final E e) throws InterruptedException {
-        if (interrupted) {
-            throw new InterruptedException("Interrupted by Unsubscribe");
-        }
-        semaphore.acquire();
-        if (interrupted) {
-            throw new InterruptedException("Interrupted by Unsubscribe");
-        }
-        if (e == null) {
-            throw new IllegalArgumentException("Can not put null");
-        }
-
-        if (offer(e)) {
-            return;
-        } else {
-            throw new IllegalStateException("Queue is full");
-        }
-    }
-
-    private boolean offer(final E e) {
-        final long _t = tail.get();
-        if (_t - head.get() == capacity) {
-            // queue is full
-            return false;
-        }
-        int index = (int) (_t & mask);
-        buffer[index] = e;
-        // move the tail forward
-        tail.lazySet(_t + 1);
-
-        return true;
-    }
-
-    public E poll() {
-        if (interrupted) {
-            return null;
-        }
-        final long _h = head.get();
-        if (tail.get() == _h) {
-            // nothing available
-            return null;
-        }
-        int index = (int) (_h & mask);
-
-        // fetch the item
-        E v = buffer[index];
-        // allow GC to happen
-        buffer[index] = null;
-        // increment and signal we're done
-        head.lazySet(_h + 1);
-        if (v != null) {
-            semaphore.release();
-        }
-        return v;
-    }
-
-    public int size()
-    {
-        int size;
-        do
-        {
-            final long currentHead = head.get();
-            final long currentTail = tail.get();
-            size = (int) (currentTail - currentHead);
-        } while (size > buffer.length);
-
-        return size;
-    }
-
-}

From 9dab6296044a04fbba80cad6f792ade06f9cf535 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Tue, 11 Feb 2014 14:56:57 -0800
Subject: [PATCH 377/441] The onCreate hook disappeared

---
 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 02fc8a63fe..09826ff1dd 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -206,7 +206,7 @@ protected Observable(OnSubscribe f) {
      * @see MSDN: Observable.Create
      */
     public final static  Observable create(OnSubscribe f) {
-        return new Observable(f);
+        return new Observable(hook.onCreate(f));
     }
 
     /**

From 673b03c8127b5da4a57d86292782bd9f5ea9633e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 11 Feb 2014 16:30:23 -0800
Subject: [PATCH 378/441] Change Lift to use rx.Observable.Operator

The generics insanity has to stop.
---
 .../java/rx/operators/DebugSubscriber.java    |  1 +
 .../src/main/java/rx/plugins/DebugHook.java   |  2 +-
 .../java/rx/plugins/DebugNotification.java    |  3 +--
 .../java/rx/plugins/NotificationEvent.java    |  2 +-
 .../java/rx/observables/StringObservable.java |  2 +-
 rxjava-core/src/main/java/rx/Observable.java  | 24 ++++++++++++-------
 .../src/main/java/rx/joins/JoinObserver1.java |  1 -
 .../rx/observables/BlockingObservable.java    |  1 -
 .../src/main/java/rx/observers/Observers.java |  1 -
 .../main/java/rx/observers/TestObserver.java  |  1 -
 .../java/rx/operators/ChunkedOperation.java   |  1 -
 .../java/rx/operators/OperationDebounce.java  |  1 -
 .../java/rx/operators/OperationDelay.java     |  1 -
 .../operators/OperationMergeDelayError.java   |  2 --
 .../main/java/rx/operators/OperationSkip.java |  1 -
 .../java/rx/operators/OperationTakeTimed.java |  1 -
 .../java/rx/operators/OperationTimer.java     |  1 -
 .../src/main/java/rx/operators/Operator.java  |  8 -------
 .../main/java/rx/operators/OperatorCast.java  |  1 +
 .../java/rx/operators/OperatorDoOnEach.java   |  1 +
 .../java/rx/operators/OperatorFilter.java     |  5 +---
 .../java/rx/operators/OperatorGroupBy.java    |  1 +
 .../main/java/rx/operators/OperatorMap.java   |  1 +
 .../main/java/rx/operators/OperatorMerge.java |  1 +
 .../java/rx/operators/OperatorObserveOn.java  |  1 +
 .../java/rx/operators/OperatorParallel.java   |  1 +
 .../java/rx/operators/OperatorRepeat.java     |  1 +
 .../rx/operators/OperatorSubscribeOn.java     |  1 +
 .../main/java/rx/operators/OperatorTake.java  |  1 +
 .../rx/operators/OperatorTimeoutBase.java     |  1 +
 .../java/rx/operators/OperatorTimestamp.java  |  1 +
 .../operators/OperatorToObservableList.java   |  1 +
 .../OperatorToObservableSortedList.java       |  1 +
 .../main/java/rx/operators/OperatorZip.java   |  1 +
 .../rx/operators/OperatorZipIterable.java     |  1 +
 .../main/java/rx/operators/SafeObserver.java  |  1 +
 .../RxJavaObservableExecutionHook.java        |  2 +-
 .../subjects/SubjectSubscriptionManager.java  |  2 +-
 .../subscriptions/CompositeSubscription.java  |  1 -
 .../rx/operators/ObservableBenchmark.java     |  1 +
 .../observers/SynchronizedObserverTest.java   |  2 --
 .../rx/operators/OperationBufferTest.java     |  1 -
 .../rx/operators/OperationDebounceTest.java   |  1 -
 .../rx/operators/OperationSampleTest.java     |  1 -
 .../rx/operators/OperationSwitchTest.java     |  1 -
 .../rx/operators/OperationWindowTest.java     |  1 -
 .../operators/OperatorFromIterableTest.java   |  6 ++---
 .../rx/operators/OperatorSubscribeOnTest.java |  5 +---
 .../java/rx/operators/OperatorTakeTest.java   |  1 +
 .../rx/operators/OperatorTimeoutTests.java    | 11 +++------
 .../OperatorTimeoutWithSelectorTest.java      |  9 ++-----
 .../rx/schedulers/AbstractSchedulerTests.java |  2 --
 52 files changed, 51 insertions(+), 72 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/Operator.java

diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
index 5e17cb9151..3f96e97b14 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
@@ -1,5 +1,6 @@
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
 import rx.plugins.DebugNotification;
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
index f530de6e79..8a50cd9da0 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
@@ -2,10 +2,10 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.operators.DebugSubscriber;
-import rx.operators.Operator;
 import rx.util.functions.Action1;
 import rx.util.functions.Actions;
 import rx.util.functions.Func1;
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
index af66b94217..f50d6c5834 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
@@ -2,11 +2,10 @@
 
 import rx.Notification;
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.observers.SafeSubscriber;
 import rx.operators.DebugSubscriber;
-import rx.operators.Operator;
-import rx.plugins.DebugNotification.Kind;
 
 public class DebugNotification {
     public static enum Kind {
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
index 998c562529..000e741b78 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
@@ -2,10 +2,10 @@
 
 import rx.Notification;
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.observers.SafeSubscriber;
 import rx.operators.DebugSubscriber;
-import rx.operators.Operator;
 
 public class NotificationEvent {
     public static enum Kind {
diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
index 4d5ba0474d..df96b64473 100644
--- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
+++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
@@ -31,8 +31,8 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.operators.Operator;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 09826ff1dd..d83e5a4dbe 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -94,7 +94,6 @@
 import rx.operators.OperationToObservableFuture;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
-import rx.operators.Operator;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorFilter;
@@ -174,7 +173,7 @@ public class Observable {
      *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
      */
     protected Observable(OnSubscribe f) {
-        this.f = f;
+        this.f = hook.onCreate(f);
     }
 
     private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
@@ -206,19 +205,28 @@ protected Observable(OnSubscribe f) {
      * @see MSDN: Observable.Create
      */
     public final static  Observable create(OnSubscribe f) {
-        return new Observable(hook.onCreate(f));
+        return new Observable(f);
     }
 
     /**
-     * 
+     * Invoked when Obserable.subscribe is called. 
      */
     public static interface OnSubscribe extends Action1> {
-
+        // cover for generics insanity
     }
+    
+    /**
+     * Operator function for lifting into an Observable.
+     */
+    public interface Operator extends Func1, Subscriber> {
+        // cover for generics insanity
+    }
+
 
     /**
-     * 
+     * @Deprecated 
      */
+    @Deprecated
     public final static  Observable create(final OnSubscribeFunc f) {
         return new Observable(new OnSubscribe() {
 
@@ -253,11 +261,11 @@ public static interface OnSubscribeFunc extends Function {
      * @param bind
      * @return an Observable that emits values that are the result of applying the bind function to the values of the current Observable
      */
-    public  Observable lift(final Func1, Subscriber> bind) {
+    public  Observable lift(final Operator bind) {
         return new Observable(new OnSubscribe() {
             @Override
             public void call(Subscriber o) {
-                subscribe(hook.onLift((Operator) bind).call(o));
+                subscribe(hook.onLift(bind).call(o));
             }
         });
     }
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index 9c3e1de1b8..cf7125455d 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -25,7 +25,6 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.observers.SafeSubscriber;
-import rx.operators.SafeObservableSubscription;
 import rx.util.functions.Action1;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index ccd4be7b71..23b6146356 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -29,7 +29,6 @@
 import rx.operators.OperationNext;
 import rx.operators.OperationToFuture;
 import rx.operators.OperationToIterator;
-import rx.operators.SafeObservableSubscription;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/observers/Observers.java b/rxjava-core/src/main/java/rx/observers/Observers.java
index 860e3c0a10..5ca66aa54b 100644
--- a/rxjava-core/src/main/java/rx/observers/Observers.java
+++ b/rxjava-core/src/main/java/rx/observers/Observers.java
@@ -1,7 +1,6 @@
 package rx.observers;
 
 import rx.Observer;
-import rx.Subscriber;
 import rx.util.OnErrorNotImplementedException;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
diff --git a/rxjava-core/src/main/java/rx/observers/TestObserver.java b/rxjava-core/src/main/java/rx/observers/TestObserver.java
index 2ef3685792..f4e278118d 100644
--- a/rxjava-core/src/main/java/rx/observers/TestObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/TestObserver.java
@@ -16,7 +16,6 @@
 package rx.observers;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 42a096212f..04125acd64 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -29,7 +29,6 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index a04566b057..0a35a2cd3c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -28,7 +28,6 @@
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 104dd850bc..6ce3e94a00 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -27,7 +27,6 @@
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index 7a31593d99..2f13510da1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -27,9 +27,7 @@
 import rx.observers.SynchronizedObserver;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
 import rx.util.CompositeException;
-import rx.util.functions.Action0;
 
 /**
  * This behaves like {@link OperatorMerge} except that if any of the merged Observables notify of
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index b74c53160d..2ab01d1f0f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -26,7 +26,6 @@
 import rx.Scheduler.Inner;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index abd63d1f34..42ba12d697 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -26,7 +26,6 @@
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index ee19ee7512..36024bdabb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -22,7 +22,6 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/Operator.java b/rxjava-core/src/main/java/rx/operators/Operator.java
deleted file mode 100644
index 6ba540e1a5..0000000000
--- a/rxjava-core/src/main/java/rx/operators/Operator.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package rx.operators;
-
-import rx.Subscriber;
-import rx.util.functions.Func1;
-
-public interface Operator extends Func1, Subscriber> {
-
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCast.java b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
index 65678cdda6..3322c8355c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
index 7c0023ec6d..d321852c72 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index 6922c23178..41b749dc75 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -15,11 +15,8 @@
  */
 package rx.operators;
 
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.observables.GroupedObservable;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index fef13f5b12..7b99bddd72 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -21,6 +21,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index 3c23124ff8..89845162ab 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index c60505cd7b..e6897764c6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -18,6 +18,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.observers.SynchronizedSubscriber;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 02917e8ccb..5fc9ed75e1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -18,6 +18,7 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicLong;
 
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
index 9e1cf294d4..9b1c76961d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.observables.GroupedObservable;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 276f52c174..d4cbaea5be 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -17,6 +17,7 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 7355a538ad..bdf33d501b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTake.java b/rxjava-core/src/main/java/rx/operators/OperatorTake.java
index e58e120386..62ab98b41c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTake.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.subscriptions.CompositeSubscription;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 71104c1782..f9ba9efc77 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -20,6 +20,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.observers.SynchronizedSubscriber;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java b/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
index 12dfef137b..c20e9c9ff8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.util.Timestamped;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
index 3b45f72d8b..3466c87ca5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
@@ -18,6 +18,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java b/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
index 90f3aa18e2..f6ddb106ba 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
@@ -20,6 +20,7 @@
 import java.util.Comparator;
 import java.util.List;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.util.functions.Func2;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 802de494b5..8b625b01b6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -19,6 +19,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
 import rx.subscriptions.CompositeSubscription;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
index 0ded7f0d5d..4bf60973b9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
@@ -17,6 +17,7 @@
 
 import java.util.Iterator;
 
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.observers.Subscribers;
 import rx.util.functions.Func2;
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index ae621d13ab..097fb84cea 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -20,6 +20,7 @@
 
 import rx.Observer;
 import rx.Subscription;
+import rx.observers.SynchronizedObserver;
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.Subscriptions;
 import rx.util.CompositeException;
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index da4500c494..e367e8e3a2 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -18,9 +18,9 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observable.OnSubscribeFunc;
+import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.operators.Operator;
 import rx.util.functions.Func1;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 81079eae1a..970e2dcdf8 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -20,10 +20,10 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
 
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.Observable.OnSubscribe;
 import rx.operators.SafeObservableSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 0c492bb861..2b1b37e581 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -16,7 +16,6 @@
 package rx.subscriptions;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
index e35815f82d..432c8ac6e1 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -11,6 +11,7 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
index 835d09a34d..bdaad282c6 100644
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
@@ -36,8 +36,6 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.operators.SafeObservableSubscription;
-import rx.operators.SafeObserver;
 
 public class SynchronizedObserverTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index a29dca6447..d6b6d86923 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -38,7 +38,6 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index b41d082578..d89c85a318 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -31,7 +31,6 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index ac4f217038..0bb0523e22 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -31,7 +31,6 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 public class OperationSampleTest {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index d560ca0f73..44a161a623 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -30,7 +30,6 @@
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 public class OperationSwitchTest {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index d403409333..6d175bfe6a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -35,7 +35,6 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
index 078482dc3e..b3c081a25c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
@@ -15,10 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index c6e01bc71d..a0dfe2e7fc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -15,10 +15,7 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 02e832d5d8..6ad7719be9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
index 11791cd4fb..c371d90680 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
@@ -15,13 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -33,10 +28,10 @@
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.Observable.OnSubscribe;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 76d19b066e..2dcb84dc8f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -15,13 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 046710bfaf..5e85b5070f 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -20,7 +20,6 @@
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
-import java.util.Date;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -39,7 +38,6 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;

From b8cc371071889bc134a904431366c83aa88051e6 Mon Sep 17 00:00:00 2001
From: Acardiac 
Date: Wed, 12 Feb 2014 04:25:07 +0100
Subject: [PATCH 379/441] Add 'Fragment-Host' to rxjava-contrib/debug module
 for OSGi

---
 rxjava-contrib/rxjava-debug/build.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rxjava-contrib/rxjava-debug/build.gradle b/rxjava-contrib/rxjava-debug/build.gradle
index 13775cd88e..6f8a913177 100644
--- a/rxjava-contrib/rxjava-debug/build.gradle
+++ b/rxjava-contrib/rxjava-debug/build.gradle
@@ -26,5 +26,6 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Fragment-Host', 'com.netflix.rxjava.core'
     }
 }

From 26a8642a75d4cb039b5e6a2deb76af1c63078c79 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Wed, 12 Feb 2014 18:10:54 +0800
Subject: [PATCH 380/441] Update the timeout docs

---
 rxjava-core/src/main/java/rx/Observable.java  | 14 ++++++-------
 .../OperatorTimeoutWithSelector.java          | 21 +++++++++++++++++++
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d83e5a4dbe..ba5de5f3a7 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7744,9 +7744,9 @@ public final Observable> timeInterval(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that completes if either the first item emitted by the source
-     * Observable or any subsequent item don't arrive within time windows defined by other
-     * Observables.
+     * Returns an Observable that mirrors the source Observable, but emits a TimeoutException
+     * if either the first item emitted by the source Observable or any subsequent item
+     * don't arrive within time windows defined by other Observables.
      * 
    
      * 
      * 
@@ -7799,16 +7799,16 @@ public final  Observable timeout(Func0> firstTi
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable, but completes if an item emitted by
+     * Returns an Observable that mirrors the source Observable, but emits a TimeoutException if an item emitted by
      * the source Observable doesn't arrive within a window of time after the emission of the
      * previous item, where that period of time is measured by an Observable that is a function
      * of the previous item.
      * 
    
      * 
      * 
    
-     * The arrival of the first source item is never timed out.
+     * Note: The arrival of the first source item is never timed out.
      * 
-     * @param 
+     * @param 
      *            the timeout value type (ignored)
      * @param timeoutSelector
      *            a function that returns an observable for each item emitted by the source
@@ -7831,7 +7831,7 @@ public final  Observable timeout(Func1>
      * 
    
      * The arrival of the first source item is never timed out.
      * 
-     * @param 
+     * @param 
      *            the timeout value type (ignored)
      * @param timeoutSelector
      *            a function that returns an observable for each item emitted by the source
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index 6f248eddd1..82727dbb01 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 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 rx.Observable;
@@ -8,6 +23,12 @@
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
+/**
+ * Returns an Observable that mirrors the source Observable. If either the first
+ * item emitted by the source Observable or any subsequent item don't arrive
+ * within time windows defined by provided Observables, switch to the
+ * other Observable if provided, or emit a TimeoutException .
+ */
 public class OperatorTimeoutWithSelector extends
         OperatorTimeoutBase {
 

From dc4ee52b8cd46eb48a7e7f60c09db2c87c428823 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 12 Feb 2014 11:17:48 +0100
Subject: [PATCH 381/441] Proposed solution to the time gap, using unbounded
 buffering.

---
 rxjava-core/src/main/java/rx/Observable.java  |  20 +-
 .../rx/operators/BufferUntilSubscriber.java   | 150 ++++++++++
 .../rx/operators/OperatorSubscribeOn.java     |  43 ++-
 .../rx/operators/OperatorSubscribeOnTest.java | 265 +++++++++++++++---
 4 files changed, 441 insertions(+), 37 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d83e5a4dbe..c419647d13 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7062,7 +7062,25 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
      * @see RxJava Wiki: subscribeOn()
      */
     public final Observable subscribeOn(Scheduler scheduler) {
-        return nest().lift(new OperatorSubscribeOn(scheduler));
+        return nest().lift(new OperatorSubscribeOn(scheduler, false));
+    }
+    /**
+     * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified {@link Scheduler}
+     * and allows buffering the events emitted from the source in the time gap between the original and
+     * actual subscription.
+     * 
    
+     * 
+     * 
+     * @param scheduler
+     *            the {@link Scheduler} to perform subscription and unsubscription actions on
+     * @param dontLoseEvents indicate that the operator should buffer events emitted in the time gap
+     *                       between the original and actual subscription and replay it to Observers
+     * @return the source Observable modified so that its subscriptions and unsubscriptions happen
+     *         on the specified {@link Scheduler}
+     * @see RxJava Wiki: subscribeOn()
+     */
+    public final Observable subscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
+        return nest().lift(new OperatorSubscribeOn(scheduler, dontLoseEvents));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
new file mode 100644
index 0000000000..ef5b85a772
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -0,0 +1,150 @@
+/**
+ * Copyright 2014 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 java.util.LinkedList;
+import java.util.Queue;
+import rx.Subscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Buffers the incoming events until notified, then replays the
+ * buffered events and continues as a simple pass-through subscriber.
+ * @param  the streamed value type
+ */
+public class BufferUntilSubscriber extends Subscriber {
+    /** The actual subscriber. */
+    private final Subscriber actual;
+    /** The mutual exclusion for the duration of the replay. */
+    private final Object gate = new Object();
+    /** Queued events. */
+    private final Queue queue = new LinkedList();
+    /** Indicate the pass-through mode. */
+    private volatile boolean passthroughMode;
+    /** Null sentinel (in case queue type is changed). */
+    private static final Object NULL_SENTINEL = new Object();
+    /** Complete sentinel. */
+    private static final Object COMPLETE_SENTINEL = new Object();
+    /**
+     * Container for an onError event.
+     */
+    private static final class ErrorSentinel {
+        final Throwable t;
+
+        public ErrorSentinel(Throwable t) {
+            this.t = t;
+        }
+        
+    }
+    /**
+     * Constructor that wraps the actual subscriber and shares its subscription.
+     * @param actual 
+     */
+    public BufferUntilSubscriber(Subscriber actual) {
+        super(actual);
+        this.actual = actual;
+    }
+    /**
+     * Constructor that wraps the actual subscriber and uses the given composite
+     * subscription.
+     * @param actual
+     * @param cs 
+     */
+    public BufferUntilSubscriber(Subscriber actual, CompositeSubscription cs) {
+        super(cs);
+        this.actual = actual;
+    }
+    
+    /**
+     * Call this method to replay the buffered events and continue as a pass-through subscriber.
+     * If already in pass-through mode, this method is a no-op.
+     */
+    public void enterPassthroughMode() {
+        if (!passthroughMode) {
+            synchronized (gate) {
+                if (!passthroughMode) {
+                    while (!queue.isEmpty()) {
+                        Object o = queue.poll();
+                        
+                        if (o == NULL_SENTINEL) {
+                            actual.onNext(null);
+                        } else
+                        if (o == COMPLETE_SENTINEL) {
+                            actual.onCompleted();
+                        } else
+                        if (o instanceof ErrorSentinel) {
+                            actual.onError(((ErrorSentinel)o).t);
+                        } else
+                        if (o != null) {
+                            @SuppressWarnings("unchecked")
+                            T v = (T)o;
+                            actual.onNext(v);
+                        } else {
+                            throw new NullPointerException();
+                        }
+                    }
+                    /* Test artificial back-pressure.
+                    try {
+                        TimeUnit.SECONDS.sleep(2);
+                    } catch (Throwable t) {
+                        
+                    }
+                    */
+                    passthroughMode = true;
+                }
+            }
+        }
+    }
+    
+    @Override
+    public void onNext(T t) {
+        if (!passthroughMode) {
+            synchronized (gate) {
+                if (!passthroughMode) {
+                    queue.offer(t != null ? t : NULL_SENTINEL);
+                    return;
+                }
+            }
+        }
+        actual.onNext(t);
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        if (!passthroughMode) {
+            synchronized (gate) {
+                if (!passthroughMode) {
+                    queue.offer(new ErrorSentinel(e));
+                    return;
+                }
+            }
+        }
+        actual.onError(e);
+    }
+
+    @Override
+    public void onCompleted() {
+        if (!passthroughMode) {
+            synchronized (gate) {
+                if (!passthroughMode) {
+                    queue.offer(COMPLETE_SENTINEL);
+                    return;
+                }
+            }
+        }
+        actual.onCompleted();
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index bdf33d501b..e77f529f04 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -20,6 +20,8 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.observables.GroupedObservable;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
@@ -33,9 +35,15 @@
 public class OperatorSubscribeOn implements Operator> {
 
     private final Scheduler scheduler;
+    /** 
+     * Indicate that events fired between the original subscription time and
+     * the actual subscription time should not get lost.
+     */
+    private final boolean dontLoseEvents;
 
-    public OperatorSubscribeOn(Scheduler scheduler) {
+    public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
         this.scheduler = scheduler;
+        this.dontLoseEvents = dontLoseEvents;
     }
 
     @Override
@@ -51,9 +59,40 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 subscriber.onError(e);
             }
-
+            boolean checkNeedBuffer(Observable o) {
+                return (o instanceof GroupedObservable)
+                        || (o instanceof PublishSubject)
+                        // || (o instanceof BehaviorSubject)
+                        ;
+            }
             @Override
             public void onNext(final Observable o) {
+                if (dontLoseEvents || checkNeedBuffer(o)) {
+                    final CompositeSubscription cs = new CompositeSubscription();
+                    subscriber.add(cs);
+                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(subscriber, new CompositeSubscription());
+                    o.subscribe(bus);
+                    scheduler.schedule(new Action1() {
+
+                        @Override
+                        public void call(final Inner inner) {
+                            cs.add(Subscriptions.create(new Action0() {
+                                @Override
+                                public void call() {
+                                    inner.schedule(new Action1() {
+                                        @Override
+                                        public void call(final Inner inner) {
+                                            bus.unsubscribe();
+                                        }
+                                    });
+                                }
+                            }));
+                            bus.enterPassthroughMode();
+                        }
+                        
+                    });
+                    return;
+                }
                 scheduler.schedule(new Action1() {
 
                     @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index a0dfe2e7fc..790eed9b72 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -1,77 +1,88 @@
-/**
- * Copyright 2014 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.
- */
+ /**
+  * Copyright 2014 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 java.util.ArrayList;
 import static org.junit.Assert.*;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.observables.GroupedObservable;
 import rx.observers.TestObserver;
+import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
 
 public class OperatorSubscribeOnTest {
-
+    
     private class ThreadSubscription implements Subscription {
         private volatile Thread thread;
-
+        
         private final CountDownLatch latch = new CountDownLatch(1);
-
+        
         private final Subscription s = Subscriptions.create(new Action0() {
-
+            
             @Override
             public void call() {
                 thread = Thread.currentThread();
                 latch.countDown();
             }
-
+            
         });
-
+        
         @Override
         public void unsubscribe() {
             s.unsubscribe();
         }
-
+        
         @Override
         public boolean isUnsubscribed() {
             return s.isUnsubscribed();
         }
-
+        
         public Thread getThread() throws InterruptedException {
             latch.await();
             return thread;
         }
     }
-
+    
     @Test
     public void testSubscribeOnAndVerifySubscribeAndUnsubscribeThreads()
             throws InterruptedException {
         final ThreadSubscription subscription = new ThreadSubscription();
         final AtomicReference subscribeThread = new AtomicReference();
         Observable w = Observable.create(new OnSubscribe() {
-
+            
             @Override
             public void call(Subscriber t1) {
                 subscribeThread.set(Thread.currentThread());
@@ -81,33 +92,33 @@ public void call(Subscriber t1) {
                 t1.onCompleted();
             }
         });
-
+        
         TestObserver observer = new TestObserver();
         w.subscribeOn(Schedulers.newThread()).subscribe(observer);
-
+        
         Thread unsubscribeThread = subscription.getThread();
-
+        
         assertNotNull(unsubscribeThread);
         assertNotSame(Thread.currentThread(), unsubscribeThread);
-
+        
         assertNotNull(subscribeThread.get());
         assertNotSame(Thread.currentThread(), subscribeThread.get());
         // True for Schedulers.newThread()
         assertTrue(unsubscribeThread == subscribeThread.get());
-
+        
         observer.assertReceivedOnNext(Arrays.asList(1, 2));
         observer.assertTerminalEvent();
     }
-
+    
     @Test
     public void testIssue813() throws InterruptedException {
         // https://github.com/Netflix/RxJava/issues/813
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch doneLatch = new CountDownLatch(1);
-
+        
         TestObserver observer = new TestObserver();
         final ThreadSubscription s = new ThreadSubscription();
-
+        
         final Subscription subscription = Observable
                 .create(new Observable.OnSubscribe() {
                     @Override
@@ -132,7 +143,7 @@ public void call(
                         }
                     }
                 }).subscribeOn(Schedulers.computation()).subscribe(observer);
-
+        
         subscription.unsubscribe();
         // As unsubscribe is called in other thread, we need to wait for it.
         s.getThread();
@@ -141,4 +152,190 @@ public void call(
         assertEquals(0, observer.getOnErrorEvents().size());
         assertEquals(1, observer.getOnCompletedEvents().size());
     }
+    
+     static class SlowScheduler extends Scheduler {
+        final Scheduler actual;
+        final long delay;
+        final TimeUnit unit;
+        public SlowScheduler() {
+            this(Schedulers.computation(), 2, TimeUnit.SECONDS);
+        }
+        public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
+            this.actual = actual;
+            this.delay = delay;
+            this.unit = unit;
+        }
+
+        @Override
+        public Subscription schedule(final Action1 action) {
+            final CompositeSubscription cs = new CompositeSubscription();
+            final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+            cs.add(mas);
+            mas.set(actual.schedule(new Action1() {
+
+                @Override
+                public void call(Inner t1) {
+//                    cs.delete(mas);
+                    cs.add(actual.schedule(action, delay, unit));
+                }
+                
+            }));
+            return cs;
+        }
+
+        @Override
+        public Subscription schedule(final Action1 action, final long delayTime, final TimeUnit delayUnit) {
+            final CompositeSubscription cs = new CompositeSubscription();
+            final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+            cs.add(mas);
+            mas.set(actual.schedule(new Action1() {
+                @Override
+                public void call(Inner t1) {
+//                    cs.delete(mas);
+                    long nanos = unit.toNanos(delay) + delayUnit.toNanos(delayTime);
+                    cs.add(actual.schedule(action, nanos, TimeUnit.NANOSECONDS));
+                }
+            }));
+            return cs;
+        }
+    }
+    
+    @Test
+    public void testSubscribeOnPublishSubjectWithSlowScheduler() {
+        PublishSubject ps = PublishSubject.create();
+        TestSubscriber ts = new TestSubscriber();
+        ps.subscribeOn(new SlowScheduler()).subscribe(ts);
+        ps.onNext(1);
+        ps.onNext(2);
+        ps.onCompleted();
+        
+        ts.awaitTerminalEvent();
+        ts.assertReceivedOnNext(Arrays.asList(1, 2));
+    }
+    
+    @Test
+    public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+            
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onCompleted();
+            }
+            
+        }).groupBy(new Func1() {
+            
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+            
+        }).flatMap(new Func1, Observable>() {
+            
+            @Override
+            public Observable call(final GroupedObservable group) {
+                return group.subscribeOn(Schedulers.newThread()).map(new Func1() {
+                    
+                    @Override
+                    public String call(Integer t1) {
+                        System.out.println("Received: " + t1 + " on group : " + group.getKey());
+                        return "first groups: " + t1;
+                    }
+                    
+                });
+            }
+            
+        }).toBlockingObservable().forEach(new Action1() {
+            
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+            
+        });
+        
+        System.out.println("Results: " + results);
+        assertEquals(4, results.size());
+    }
+    
+    @Test
+    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
+        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+            
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                try {
+                    first.await();
+                } catch (InterruptedException e) {
+                    sub.onError(e);
+                    return;
+                }
+                sub.onNext(3);
+                sub.onNext(3);
+                sub.onCompleted();
+            }
+            
+        }).groupBy(new Func1() {
+            
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+            
+        }).flatMap(new Func1, Observable>() {
+            
+            @Override
+            public Observable call(final GroupedObservable group) {
+                if (group.getKey() < 3) {
+                    return group.map(new Func1() {
+                        
+                        @Override
+                        public String call(Integer t1) {
+                            return "first groups: " + t1;
+                        }
+                        
+                    })
+                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
+                            .take(2).doOnCompleted(new Action0() {
+                                
+                                @Override
+                                public void call() {
+                                    first.countDown();
+                                }
+                                
+                            });
+                } else {
+                    return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+                        
+                        @Override
+                        public String call(Integer t1) {
+                            return "last group: " + t1;
+                        }
+                        
+                    });
+                }
+            }
+            
+        }).toBlockingObservable().forEach(new Action1() {
+            
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+            
+        });
+        
+        System.out.println("Results: " + results);
+        assertEquals(6, results.size());
+    }
 }

From 98e75c2044a97166ca7e96ca9ce16055c07eaab6 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Wed, 12 Feb 2014 01:16:20 -0800
Subject: [PATCH 382/441] Fixing the generics for merge and lift

---
 .../java/rx/operators/DebugSubscriber.java    |  18 +--
 .../src/main/java/rx/plugins/DebugHook.java   |   6 +-
 .../java/rx/plugins/DebugNotification.java    |  22 ++--
 .../java/rx/plugins/NotificationEvent.java    | 104 ------------------
 rxjava-core/src/main/java/rx/Observable.java  |  22 ++--
 .../main/java/rx/operators/OperatorMerge.java |   8 +-
 .../RxJavaObservableExecutionHook.java        |   2 +-
 7 files changed, 39 insertions(+), 143 deletions(-)
 delete mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java

diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
index 3f96e97b14..01de861b04 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
@@ -11,15 +11,15 @@ public final class DebugSubscriber extends Subscriber {
     private final Func1 onNextHook;
     final Action1 events;
     final Observer o;
-    Operator from = null;
-    Operator to = null;
+    Operator from = null;
+    Operator to = null;
 
     public DebugSubscriber(
             Func1 onNextHook,
             Action1 _events,
             Subscriber _o,
-            Operator _out,
-            Operator _in) {
+            Operator _out,
+            Operator _in) {
         super(_o);
         this.events = _events;
         this.o = _o;
@@ -47,19 +47,19 @@ public void onNext(T t) {
         o.onNext(onNextHook.call(t));
     }
 
-    public Operator getFrom() {
+    public Operator getFrom() {
         return from;
     }
 
-    public void setFrom(Operator op) {
-        this.from = op;
+    public void setFrom(Operator bind) {
+        this.from = bind;
     }
 
-    public Operator getTo() {
+    public Operator getTo() {
         return to;
     }
 
-    public void setTo(Operator op) {
+    public void setTo(Operator op) {
         this.to = op;
     }
 
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
index 8a50cd9da0..f52d5f945c 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
@@ -63,7 +63,7 @@ public void call(Subscriber o) {
     }
 
     @Override
-    public  Operator onLift(final Operator bind) {
+    public  Operator onLift(final Operator bind) {
         return new Operator() {
             @Override
             public Subscriber call(final Subscriber o) {
@@ -78,7 +78,7 @@ public  Subscription onAdd(Subscriber subscriber, Subscription s) {
     }
 
     @SuppressWarnings("unchecked")
-    private  Subscriber wrapOutbound(Operator bind, Subscriber o) {
+    private  Subscriber wrapOutbound(Operator bind, Subscriber o) {
         if (o instanceof DebugSubscriber) {
             if (bind != null)
                 ((DebugSubscriber) o).setFrom(bind);
@@ -88,7 +88,7 @@ private  Subscriber wrapOutbound(Operator bind, Subscriber Subscriber wrapInbound(Operator bind, Subscriber o) {
+    private  Subscriber wrapInbound(Operator bind, Subscriber o) {
         if (o instanceof DebugSubscriber) {
             if (bind != null)
                 ((DebugSubscriber) o).setTo(bind);
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
index f50d6c5834..f4144fb2b0 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java
@@ -13,17 +13,17 @@ public static enum Kind {
     }
 
     private final OnSubscribe source;
-    private final Operator from;
+    private final Operator from;
     private final Kind kind;
     private final Notification notification;
-    private final Operator to;
+    private final Operator to;
     private final long nanoTime;
     private final long threadId;
     private Observer o;
 
     public static  DebugNotification createSubscribe(Observer o, OnSubscribe source) {
-        Operator to = null;
-        Operator from = null;
+        Operator to = null;
+        Operator from = null;
         if (o instanceof DebugSubscriber) {
             to = ((DebugSubscriber) o).getTo();
             from = ((DebugSubscriber) o).getFrom();
@@ -32,23 +32,23 @@ public static  DebugNotification createSubscribe(Observer o, On
         return new DebugNotification(o, from, Kind.Subscribe, null, to, source);
     }
 
-    public static  DebugNotification createOnNext(Observer o, Operator from, T t, Operator to) {
+    public static  DebugNotification createOnNext(Observer o, Operator from, T t, Operator to) {
         return new DebugNotification(o, from, Kind.OnNext, Notification.createOnNext(t), to, null);
     }
 
-    public static  DebugNotification createOnError(Observer o, Operator from, Throwable e, Operator to) {
+    public static  DebugNotification createOnError(Observer o, Operator from, Throwable e, Operator to) {
         return new DebugNotification(o, from, Kind.OnError, Notification. createOnError(e), to, null);
     }
 
-    public static  DebugNotification createOnCompleted(Observer o, Operator from, Operator to) {
+    public static  DebugNotification createOnCompleted(Observer o, Operator from, Operator to) {
         return new DebugNotification(o, from, Kind.OnCompleted, Notification. createOnCompleted(), to, null);
     }
 
-    public static  DebugNotification createUnsubscribe(Observer o, Operator from, Operator to) {
+    public static  DebugNotification createUnsubscribe(Observer o, Operator from, Operator to) {
         return new DebugNotification(o, from, Kind.Unsubscribe, null, to, null);
     }
 
-    private DebugNotification(Observer o, Operator from, Kind kind, Notification notification, Operator to, OnSubscribe source) {
+    private DebugNotification(Observer o, Operator from, Kind kind, Notification notification, Operator to, OnSubscribe source) {
         this.o = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
         this.from = from;
         this.kind = kind;
@@ -59,7 +59,7 @@ private DebugNotification(Observer o, Operator from, Kind kind, Notificati
         this.threadId = Thread.currentThread().getId();
     }
 
-    public Operator getFrom() {
+    public Operator getFrom() {
         return from;
     }
 
@@ -67,7 +67,7 @@ public Notification getNotification() {
         return notification;
     }
 
-    public Operator getTo() {
+    public Operator getTo() {
         return to;
     }
 
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
deleted file mode 100644
index 000e741b78..0000000000
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/NotificationEvent.java
+++ /dev/null
@@ -1,104 +0,0 @@
-package rx.plugins;
-
-import rx.Notification;
-import rx.Observable.OnSubscribe;
-import rx.Observable.Operator;
-import rx.Observer;
-import rx.observers.SafeSubscriber;
-import rx.operators.DebugSubscriber;
-
-public class NotificationEvent {
-    public static enum Kind {
-        OnNext, OnError, OnCompleted, Subscribe, Unsubscribe
-    }
-
-    private final OnSubscribe source;
-    private final Operator from;
-    private final Kind kind;
-    private final Notification notification;
-    private final Operator to;
-    private final long nanoTime;
-    private final long threadId;
-    private Observer o;
-
-    public static  NotificationEvent createSubscribe(Observer o, OnSubscribe source) {
-        Operator to = null;
-        Operator from = null;
-        if (o instanceof DebugSubscriber) {
-            to = ((DebugSubscriber) o).getTo();
-            from = ((DebugSubscriber) o).getFrom();
-            o = ((DebugSubscriber) o).getActual();
-        }
-        return new NotificationEvent(o, from, Kind.Subscribe, null, to, source);
-    }
-
-    public static  NotificationEvent createOnNext(Observer o, Operator from, T t, Operator to) {
-        return new NotificationEvent(o, from, Kind.OnNext, Notification.createOnNext(t), to, null);
-    }
-
-    public static  NotificationEvent createOnError(Observer o, Operator from, Throwable e, Operator to) {
-        return new NotificationEvent(o, from, Kind.OnError, Notification. createOnError(e), to, null);
-    }
-
-    public static  NotificationEvent createOnCompleted(Observer o, Operator from, Operator to) {
-        return new NotificationEvent(o, from, Kind.OnCompleted, Notification. createOnCompleted(), to, null);
-    }
-
-    public static  NotificationEvent createUnsubscribe(Observer o, Operator from, Operator to) {
-        return new NotificationEvent(o, from, Kind.Unsubscribe, null, to, null);
-    }
-
-    private NotificationEvent(Observer o, Operator from, Kind kind, Notification notification, Operator to, OnSubscribe source) {
-        this.o = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
-        this.from = from;
-        this.kind = kind;
-        this.notification = notification;
-        this.to = to;
-        this.source = source;
-        this.nanoTime = System.nanoTime();
-        this.threadId = Thread.currentThread().getId();
-    }
-
-    public Operator getFrom() {
-        return from;
-    }
-
-    public Notification getNotification() {
-        return notification;
-    }
-
-    public Operator getTo() {
-        return to;
-    }
-
-    public long getNanoTime() {
-        return nanoTime;
-    }
-
-    public long getThreadId() {
-        return threadId;
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder s = new StringBuilder("{");
-        s.append(" \"nano\": ").append(nanoTime);
-        s.append(", \"thread\": ").append(threadId);
-        s.append(", \"observer\": \"").append(o.getClass().getName()).append("@").append(Integer.toHexString(o.hashCode())).append("\"");
-        s.append(", \"type\": \"").append(kind).append("\"");
-        if (notification != null) {
-            if (notification.hasValue())
-                s.append(", \"value\": \"").append(notification.getValue()).append("\"");
-            if (notification.hasThrowable())
-                s.append(", \"exception\": \"").append(notification.getThrowable().getMessage().replace("\\", "\\\\").replace("\"", "\\\"")).append("\"");
-        }
-        if (source != null)
-            s.append(", \"source\": \"").append(source.getClass().getName()).append("@").append(Integer.toHexString(source.hashCode())).append("\"");
-        if (from != null)
-            s.append(", \"from\": \"").append(from.getClass().getName()).append("@").append(Integer.toHexString(from.hashCode())).append("\"");
-        if (to != null)
-            s.append(", \"to\": \"").append(to.getClass().getName()).append("@").append(Integer.toHexString(to.hashCode())).append("\"");
-        s.append("}");
-        return s.toString();
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d83e5a4dbe..1dedc27516 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -261,7 +261,7 @@ public static interface OnSubscribeFunc extends Function {
      * @param bind
      * @return an Observable that emits values that are the result of applying the bind function to the values of the current Observable
      */
-    public  Observable lift(final Operator bind) {
+    public  Observable lift(final Operator bind) {
         return new Observable(new OnSubscribe() {
             @Override
             public void call(Subscriber o) {
@@ -1777,7 +1777,7 @@ public final static  Observable merge(IterableMSDN: Observable.Merge
      */
     public final static  Observable merge(Observable> source) {
-        return source.lift(new OperatorMerge()); // any idea how to get these generics working?!
+        return source.lift(new OperatorMerge());
     }
 
     /**
@@ -1821,7 +1821,7 @@ public final static  Observable merge(ObservableMSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2) {
-        return merge(from(t1, t2));
+        return merge(from(Arrays.asList(t1, t2)));
     }
 
     /**
@@ -1843,7 +1843,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3) {
-        return merge(from(t1, t2, t3));
+        return merge(from(Arrays.asList(t1, t2, t3)));
     }
 
     /**
@@ -1867,7 +1867,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4) {
-        return merge(from(t1, t2, t3, t4));
+        return merge(from(Arrays.asList(t1, t2, t3, t4)));
     }
 
     /**
@@ -1893,7 +1893,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) {
-        return merge(from(t1, t2, t3, t4, t5));
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5)));
     }
 
     /**
@@ -1921,7 +1921,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) {
-        return merge(from(t1, t2, t3, t4, t5, t6));
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6)));
     }
 
     /**
@@ -1951,7 +1951,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) {
-        return merge(from(t1, t2, t3, t4, t5, t6, t7));
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)));
     }
 
     /**
@@ -1984,7 +1984,7 @@ public final static  Observable merge(Observable t1, Observab
      * @see MSDN: Observable.Merge
      */
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) {
-        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8));
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)));
     }
 
     /**
@@ -2019,7 +2019,7 @@ public final static  Observable merge(Observable t1, Observab
      */
     // suppress because the types are checked by the method signature before using a vararg
     public final static  Observable merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) {
-        return merge(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)));
     }
 
     /**
@@ -4863,7 +4863,7 @@ public final  Observable map(Func1 func) {
      * @deprecated use {@link #flatMap(Func1)}
      */
     @Deprecated
-    public final  Observable mapMany(Func1> func) {
+    public final  Observable mapMany(Func1> func) {
         return mergeMap(func);
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index e6897764c6..9425916dac 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -30,13 +30,13 @@
  * You can combine the items emitted by multiple Observables so that they act like a single
  * Observable, by using the merge operation.
  */
-public final class OperatorMerge implements Operator> {
+public final class OperatorMerge implements Operator> {
 
     @Override
-    public Subscriber> call(final Subscriber outerOperation) {
+    public Subscriber> call(final Subscriber outerOperation) {
 
         final Subscriber o = new SynchronizedSubscriber(outerOperation);
-        return new Subscriber>(outerOperation) {
+        return new Subscriber>(outerOperation) {
 
             private volatile boolean completed = false;
             private final AtomicInteger runningCount = new AtomicInteger();
@@ -55,7 +55,7 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(Observable innerObservable) {
+            public void onNext(Observable innerObservable) {
                 runningCount.incrementAndGet();
                 innerObservable.subscribe(new InnerObserver());
             }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index e367e8e3a2..2c1c3f67e9 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -97,7 +97,7 @@ public  OnSubscribe onCreate(OnSubscribe f) {
         return f;
     }
 
-    public  Operator onLift(final Operator bind) {
+    public  Operator onLift(final Operator bind) {
         return bind;
     }
 

From d764c1b09de4470e98cb36d7e7300536fc8d9ef7 Mon Sep 17 00:00:00 2001
From: Acardiac 
Date: Wed, 12 Feb 2014 13:41:25 +0100
Subject: [PATCH 383/441] Optimize Swing-RelativeMouseMotion pipeline

---
 .../rx/swing/sources/MouseEventSource.java    | 33 +++----------------
 1 file changed, 5 insertions(+), 28 deletions(-)

diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
index f6589da054..ebf5e5cd62 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
@@ -120,36 +120,13 @@ public void call() {
      * @see rx.observables.SwingObservable#fromRelativeMouseMotion
      */
     public static Observable fromRelativeMouseMotion(final Component component) {
-        class OldAndRelative {
-            public final Point old;
-            public final Point relative;
-
-            private OldAndRelative(Point old, Point relative) {
-                this.old = old;
-                this.relative = relative;
-            }
-        }
-        
-        class Relativize implements Func2 {
+        final Observable events = fromMouseMotionEventsOf(component);
+        return Observable.zip(events, events.skip(1), new Func2() {
             @Override
-            public OldAndRelative call(OldAndRelative last, MouseEvent event) {
-                Point current = new Point(event.getX(), event.getY());
-                Point relative = new Point(current.x - last.old.x, current.y - last.old.y);
-                return new OldAndRelative(current, relative);
+            public Point call(MouseEvent ev1, MouseEvent ev2) {
+                return new Point(ev2.getX() - ev1.getX(), ev2.getY() - ev1.getY());
             }
-        }
-        
-        class OnlyRelative implements Func1 {
-            @Override
-            public Point call(OldAndRelative oar) {
-                return oar.relative;
-            }
-        }
-        
-        return fromMouseMotionEventsOf(component)
-                    .scan(new OldAndRelative(new Point(0, 0), new Point(0, 0)), new Relativize())
-                    .map(new OnlyRelative())
-                    .skip(2); // skip the useless initial value and the invalid first computation
+        });
     }
     
     public static class UnitTest {

From dade7e12f304068c233abcf2decc562860067422 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 12 Feb 2014 14:19:02 +0100
Subject: [PATCH 384/441] Added bounded buffering capability to SubscribeOn

---
 rxjava-core/src/main/java/rx/Observable.java  | 17 ++--
 .../rx/operators/BufferUntilSubscriber.java   | 75 ++++++++++++-----
 .../rx/operators/OperatorSubscribeOn.java     | 24 ++++--
 .../rx/operators/OperatorSubscribeOnTest.java | 84 +++++++++++++------
 4 files changed, 140 insertions(+), 60 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c419647d13..639a711d02 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7060,27 +7060,32 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
      * @return the source Observable modified so that its subscriptions and unsubscriptions happen
      *         on the specified {@link Scheduler}
      * @see RxJava Wiki: subscribeOn()
+     * @see #subscribeOn(rx.Scheduler, int) 
      */
     public final Observable subscribeOn(Scheduler scheduler) {
         return nest().lift(new OperatorSubscribeOn(scheduler, false));
     }
     /**
      * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified {@link Scheduler}
-     * and allows buffering the events emitted from the source in the time gap between the original and
-     * actual subscription.
+     * and allows buffering some events emitted from the source in the time gap between the original and
+     * actual subscription, and any excess events will block the source until the actual subscription happens.
+     * 
    
+     * This overload should help mitigate issues when subscribing to a PublishSubject (and derivatives
+     * such as GroupedObservable in operator groupBy) and events fired between the original and actual subscriptions
+     * are lost. 
      * 
    
      * 
      * 
      * @param scheduler
      *            the {@link Scheduler} to perform subscription and unsubscription actions on
-     * @param dontLoseEvents indicate that the operator should buffer events emitted in the time gap
-     *                       between the original and actual subscription and replay it to Observers
+     * @param bufferSize the number of events to buffer before blocking the source while in the time gap,
+     *                   negative value indicates an unlimited buffer
      * @return the source Observable modified so that its subscriptions and unsubscriptions happen
      *         on the specified {@link Scheduler}
      * @see RxJava Wiki: subscribeOn()
      */
-    public final Observable subscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
-        return nest().lift(new OperatorSubscribeOn(scheduler, dontLoseEvents));
+    public final Observable subscribeOn(Scheduler scheduler, int bufferSize) {
+        return nest().lift(new OperatorSubscribeOn(scheduler, true, bufferSize));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index ef5b85a772..676ed69afd 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -28,12 +28,14 @@
 public class BufferUntilSubscriber extends Subscriber {
     /** The actual subscriber. */
     private final Subscriber actual;
-    /** The mutual exclusion for the duration of the replay. */
-    private final Object gate = new Object();
-    /** Queued events. */
-    private final Queue queue = new LinkedList();
     /** Indicate the pass-through mode. */
     private volatile boolean passthroughMode;
+    /** Protect mode transition. */
+    private final Object gate = new Object();
+    /** The buffered items. */
+    private final Queue queue = new LinkedList();
+    /** The queue capacity. */
+    private final int capacity;
     /** Null sentinel (in case queue type is changed). */
     private static final Object NULL_SENTINEL = new Object();
     /** Complete sentinel. */
@@ -51,21 +53,25 @@ public ErrorSentinel(Throwable t) {
     }
     /**
      * Constructor that wraps the actual subscriber and shares its subscription.
-     * @param actual 
+     * @param capacity the queue capacity to accept before blocking, negative value indicates an unbounded queue
+     * @param actual
      */
-    public BufferUntilSubscriber(Subscriber actual) {
+    public BufferUntilSubscriber(int capacity, Subscriber actual) {
         super(actual);
         this.actual = actual;
+        this.capacity = capacity;
     }
     /**
      * Constructor that wraps the actual subscriber and uses the given composite
      * subscription.
+     * @param capacity the queue capacity to accept before blocking, negative value indicates an unbounded queue
      * @param actual
      * @param cs 
      */
-    public BufferUntilSubscriber(Subscriber actual, CompositeSubscription cs) {
+    public BufferUntilSubscriber(int capacity, Subscriber actual, CompositeSubscription cs) {
         super(cs);
         this.actual = actual;
+        this.capacity = capacity;
     }
     
     /**
@@ -96,26 +102,30 @@ public void enterPassthroughMode() {
                             throw new NullPointerException();
                         }
                     }
-                    /* Test artificial back-pressure.
-                    try {
-                        TimeUnit.SECONDS.sleep(2);
-                    } catch (Throwable t) {
-                        
-                    }
-                    */
                     passthroughMode = true;
+                    gate.notifyAll();
                 }
             }
         }
     }
-    
     @Override
     public void onNext(T t) {
         if (!passthroughMode) {
             synchronized (gate) {
                 if (!passthroughMode) {
-                    queue.offer(t != null ? t : NULL_SENTINEL);
-                    return;
+                    if (capacity < 0 || queue.size() < capacity) {
+                        queue.offer(t != null ? t : NULL_SENTINEL);
+                        return;
+                    }
+                    try {
+                        while (!passthroughMode) {
+                            gate.wait();
+                        }
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                        actual.onError(ex);
+                        return;
+                    }
                 }
             }
         }
@@ -127,8 +137,19 @@ public void onError(Throwable e) {
         if (!passthroughMode) {
             synchronized (gate) {
                 if (!passthroughMode) {
-                    queue.offer(new ErrorSentinel(e));
-                    return;
+                    if (capacity < 0 || queue.size() < capacity) {
+                        queue.offer(new ErrorSentinel(e));
+                        return;
+                    }
+                    try {
+                        while (!passthroughMode) {
+                            gate.wait();
+                        }
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                        actual.onError(ex);
+                        return;
+                    }
                 }
             }
         }
@@ -140,11 +161,23 @@ public void onCompleted() {
         if (!passthroughMode) {
             synchronized (gate) {
                 if (!passthroughMode) {
-                    queue.offer(COMPLETE_SENTINEL);
-                    return;
+                    if (capacity < 0 || queue.size() < capacity) {
+                        queue.offer(COMPLETE_SENTINEL);
+                        return;
+                    }
+                    try {
+                        while (!passthroughMode) {
+                            gate.wait();
+                        }
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                        actual.onError(ex);
+                        return;
+                    }
                 }
             }
         }
         actual.onCompleted();
     }
+
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index e77f529f04..55bef3bfdb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -40,10 +40,22 @@ public class OperatorSubscribeOn implements Operator> {
      * the actual subscription time should not get lost.
      */
     private final boolean dontLoseEvents;
-
+    /** The buffer size to avoid flooding. Negative value indicates an unbounded buffer. */
+    private final int bufferSize;
     public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
+        this(scheduler, dontLoseEvents, -1);
+    }
+    /**
+     * Construct a SubscribeOn operator.
+     * @param scheduler the target scheduler
+     * @param dontLoseEvents indicate that events should be buffered until the actual subscription happens
+     * @param bufferSize if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
+     * block the source. -1 indicates an unbounded buffer
+     */
+    public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents, int bufferSize) {
         this.scheduler = scheduler;
         this.dontLoseEvents = dontLoseEvents;
+        this.bufferSize = bufferSize;
     }
 
     @Override
@@ -60,20 +72,19 @@ public void onError(Throwable e) {
                 subscriber.onError(e);
             }
             boolean checkNeedBuffer(Observable o) {
-                return (o instanceof GroupedObservable)
+                return dontLoseEvents || ((o instanceof GroupedObservable)
                         || (o instanceof PublishSubject)
                         // || (o instanceof BehaviorSubject)
-                        ;
+                        );
             }
             @Override
             public void onNext(final Observable o) {
-                if (dontLoseEvents || checkNeedBuffer(o)) {
+                if (checkNeedBuffer(o)) {
                     final CompositeSubscription cs = new CompositeSubscription();
                     subscriber.add(cs);
-                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(subscriber, new CompositeSubscription());
+                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(bufferSize, subscriber, new CompositeSubscription());
                     o.subscribe(bus);
                     scheduler.schedule(new Action1() {
-
                         @Override
                         public void call(final Inner inner) {
                             cs.add(Subscriptions.create(new Action0() {
@@ -89,7 +100,6 @@ public void call(final Inner inner) {
                             }));
                             bus.enterPassthroughMode();
                         }
-                        
                     });
                     return;
                 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 790eed9b72..b05b7724f8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -19,9 +19,12 @@
 import static org.junit.Assert.*;
 
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Ignore;
 
 import org.junit.Test;
 
@@ -39,6 +42,7 @@
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
+import rx.util.Timestamped;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
@@ -153,7 +157,7 @@ public void call(
         assertEquals(1, observer.getOnCompletedEvents().size());
     }
     
-     static class SlowScheduler extends Scheduler {
+    public static class SlowScheduler extends Scheduler {
         final Scheduler actual;
         final long delay;
         final TimeUnit unit;
@@ -168,35 +172,14 @@ public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
 
         @Override
         public Subscription schedule(final Action1 action) {
-            final CompositeSubscription cs = new CompositeSubscription();
-            final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-            cs.add(mas);
-            mas.set(actual.schedule(new Action1() {
-
-                @Override
-                public void call(Inner t1) {
-//                    cs.delete(mas);
-                    cs.add(actual.schedule(action, delay, unit));
-                }
-                
-            }));
-            return cs;
+            return actual.schedule(action, delay, unit);
         }
 
         @Override
         public Subscription schedule(final Action1 action, final long delayTime, final TimeUnit delayUnit) {
-            final CompositeSubscription cs = new CompositeSubscription();
-            final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-            cs.add(mas);
-            mas.set(actual.schedule(new Action1() {
-                @Override
-                public void call(Inner t1) {
-//                    cs.delete(mas);
-                    long nanos = unit.toNanos(delay) + delayUnit.toNanos(delayTime);
-                    cs.add(actual.schedule(action, nanos, TimeUnit.NANOSECONDS));
-                }
-            }));
-            return cs;
+            TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit;
+            long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit);
+            return actual.schedule(action, t, common);
         }
     }
     
@@ -338,4 +321,53 @@ public void call(String s) {
         System.out.println("Results: " + results);
         assertEquals(6, results.size());
     }
+    void testBoundedBufferingWithSize(int size) throws Exception {
+        Observable timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS);
+
+        final List deltas = Collections.synchronizedList(new ArrayList());
+        
+        Subscription s = timer.timestamp().subscribeOn(
+                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size).map(new Func1, Long>() {
+            @Override
+            public Long call(Timestamped t1) {
+                long v = System.currentTimeMillis() - t1.getTimestampMillis();
+                return v;
+            }
+        }).doOnNext(new Action1() {
+            @Override
+            public void call(Long t1) {
+                deltas.add(t1);
+            }
+        }).subscribe();
+        
+        Thread.sleep(2050);
+        
+        s.unsubscribe();
+        
+        if (deltas.size() < size + 1) {
+            fail("To few items in deltas: " + deltas);
+        }
+        for (int i = 0; i < size + 1; i++) {
+            if (deltas.get(i) < 500) {
+                fail(i + "th item arrived too early: " + deltas);
+            }
+        }
+        for (int i = size + 1; i < deltas.size(); i++) {
+            if (deltas.get(i) >= 500) {
+                fail(i + "th item arrived too late: " + deltas);
+            }
+        }
+    }
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfZero() throws Exception {
+        testBoundedBufferingWithSize(0);
+    }
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfOne() throws Exception {
+        testBoundedBufferingWithSize(1);
+    }
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfTwo() throws Exception {
+        testBoundedBufferingWithSize(2);
+    }
 }

From 5209ab102a30ef996f46a315cd350ec336228177 Mon Sep 17 00:00:00 2001
From: akarnokd 
Date: Wed, 12 Feb 2014 14:41:14 +0100
Subject: [PATCH 385/441] Check child unsubscription status more eagerly.

---
 .../rx/operators/BufferUntilSubscriber.java   | 42 ++++++++++++-------
 1 file changed, 26 insertions(+), 16 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index 676ed69afd..7526674636 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -84,22 +84,23 @@ public void enterPassthroughMode() {
                 if (!passthroughMode) {
                     while (!queue.isEmpty()) {
                         Object o = queue.poll();
-                        
-                        if (o == NULL_SENTINEL) {
-                            actual.onNext(null);
-                        } else
-                        if (o == COMPLETE_SENTINEL) {
-                            actual.onCompleted();
-                        } else
-                        if (o instanceof ErrorSentinel) {
-                            actual.onError(((ErrorSentinel)o).t);
-                        } else
-                        if (o != null) {
-                            @SuppressWarnings("unchecked")
-                            T v = (T)o;
-                            actual.onNext(v);
-                        } else {
-                            throw new NullPointerException();
+                        if (!actual.isUnsubscribed()) {
+                            if (o == NULL_SENTINEL) {
+                                actual.onNext(null);
+                            } else
+                            if (o == COMPLETE_SENTINEL) {
+                                actual.onCompleted();
+                            } else
+                            if (o instanceof ErrorSentinel) {
+                                actual.onError(((ErrorSentinel)o).t);
+                            } else
+                            if (o != null) {
+                                @SuppressWarnings("unchecked")
+                                T v = (T)o;
+                                actual.onNext(v);
+                            } else {
+                                throw new NullPointerException();
+                            }
                         }
                     }
                     passthroughMode = true;
@@ -121,6 +122,9 @@ public void onNext(T t) {
                         while (!passthroughMode) {
                             gate.wait();
                         }
+                        if (actual.isUnsubscribed()) {
+                            return;
+                        }
                     } catch (InterruptedException ex) {
                         Thread.currentThread().interrupt();
                         actual.onError(ex);
@@ -145,6 +149,9 @@ public void onError(Throwable e) {
                         while (!passthroughMode) {
                             gate.wait();
                         }
+                        if (actual.isUnsubscribed()) {
+                            return;
+                        }
                     } catch (InterruptedException ex) {
                         Thread.currentThread().interrupt();
                         actual.onError(ex);
@@ -169,6 +176,9 @@ public void onCompleted() {
                         while (!passthroughMode) {
                             gate.wait();
                         }
+                        if (actual.isUnsubscribed()) {
+                            return;
+                        }
                     } catch (InterruptedException ex) {
                         Thread.currentThread().interrupt();
                         actual.onError(ex);

From 67374198e9dc1e3e00dd56f5c53984af3cc1a721 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Tue, 28 Jan 2014 00:15:02 -0800
Subject: [PATCH 386/441] Convert to scan to use lift

---
 rxjava-core/src/main/java/rx/Observable.java  |  26 +-
 .../main/java/rx/operators/OperationScan.java | 188 +++++------
 .../main/java/rx/operators/OperationSum.java  | 291 +++---------------
 rxjava-core/src/test/java/rx/ReduceTests.java |   2 +-
 .../java/rx/operators/OperationScanTest.java  |   6 +-
 .../java/rx/operators/OperationSumTest.java   |   4 +-
 6 files changed, 132 insertions(+), 385 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 544a60d712..a5a265fa8b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2529,14 +2529,6 @@ public final static  Observable sequenceEqual(Observable sum(Observable source) {
-        return OperationSum.sum(source);
-    }
-
     /**
      * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
      * 
    
@@ -2583,7 +2575,7 @@ public final static Observable sumFloat(Observable source) {
      * @see MSDN: Observable.Sum
      */
     public final static Observable sumInteger(Observable source) {
-        return OperationSum.sum(source);
+        return OperationSum.sumIntegers(source);
     }
 
     /**
@@ -5519,7 +5511,7 @@ public final Observable reduce(Func2 accumulator) {
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is
          * empty.
          */
-        return create(OperationScan.scan(this, accumulator)).last();
+        return scan(accumulator).last();
     }
 
     /**
@@ -5547,7 +5539,7 @@ public final Observable reduce(Func2 accumulator) {
      * @see Wikipedia: Fold (higher-order function)
      */
     public final  Observable reduce(R initialValue, Func2 accumulator) {
-        return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
+        return scan(initialValue, accumulator).takeLast(1);
     }
 
     /**
@@ -6148,7 +6140,7 @@ public final  Observable sample(Observable sampler) {
      * @see MSDN: Observable.Scan
      */
     public final Observable scan(Func2 accumulator) {
-        return create(OperationScan.scan(this, accumulator));
+        return lift(OperationScan.scan(accumulator));
     }
 
     /**
@@ -6175,7 +6167,7 @@ public final Observable scan(Func2 accumulator) {
      * @see MSDN: Observable.Scan
      */
     public final  Observable scan(R initialValue, Func2 accumulator) {
-        return create(OperationScan.scan(this, initialValue, accumulator));
+        return lift(OperationScan.scan(initialValue, accumulator));
     }
 
     /**
@@ -7079,7 +7071,7 @@ public final Observable subscribeOn(Scheduler scheduler) {
      * @see MSDN: Observable.Sum
      */
     public final Observable sumDouble(Func1 valueExtractor) {
-        return create(new OperationSum.SumDoubleExtractor(this, valueExtractor));
+        return OperationSum.sumAtLeastOneDoubles(map(valueExtractor));
     }
 
     /**
@@ -7096,7 +7088,7 @@ public final Observable sumDouble(Func1 valueExtracto
      * @see MSDN: Observable.Sum
      */
     public final Observable sumFloat(Func1 valueExtractor) {
-        return create(new OperationSum.SumFloatExtractor(this, valueExtractor));
+        return OperationSum.sumAtLeastOneFloats(map(valueExtractor));
     }
 
     /**
@@ -7113,7 +7105,7 @@ public final Observable sumFloat(Func1 valueExtractor)
      * @see MSDN: Observable.Sum
      */
     public final Observable sumInteger(Func1 valueExtractor) {
-        return create(new OperationSum.SumIntegerExtractor(this, valueExtractor));
+        return OperationSum.sumAtLeastOneIntegers(map(valueExtractor));
     }
 
     /**
@@ -7130,7 +7122,7 @@ public final Observable sumInteger(Func1 valueExtra
      * @see MSDN: Observable.Sum
      */
     public final Observable sumLong(Func1 valueExtractor) {
-        return create(new OperationSum.SumLongExtractor(this, valueExtractor));
+        return OperationSum.sumAtLeastOneLongs(map(valueExtractor));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationScan.java b/rxjava-core/src/main/java/rx/operators/OperationScan.java
index 3c58e053c5..8bbaeb0e59 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationScan.java
@@ -15,10 +15,8 @@
  */
 package rx.operators;
 
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.Operator;
+import rx.Subscriber;
 import rx.util.functions.Func2;
 
 /**
@@ -36,7 +34,8 @@
  */
 public final class OperationScan {
     /**
-     * Applies an accumulator function over an observable sequence and returns each intermediate result with the specified source and accumulator.
+     * Applies an accumulator function over an observable sequence and returns each intermediate
+     * result with the specified source and accumulator.
      * 
      * @param sequence
      *            An observable sequence of elements to project.
@@ -45,124 +44,97 @@ public final class OperationScan {
      * @param accumulator
      *            An accumulator function to be invoked on each element from the sequence.
      * 
-     * @return An observable sequence whose elements are the result of accumulating the output from the list of Observables.
-     * @see Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
+     * @return An observable sequence whose elements are the result of accumulating the output from
+     *         the list of Observables.
+     * @see Observable.Scan(TSource,
+     *      TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
      *      TAccumulate))
      */
-    public static  OnSubscribeFunc scan(Observable sequence, R initialValue, Func2 accumulator) {
-        return new Accumulator(sequence, initialValue, accumulator);
+    public static  Operator scan(final R initialValue, final Func2 accumulator) {
+        return new Operator() {
+            @Override
+            public Subscriber call(final Subscriber observer) {
+                observer.onNext(initialValue);
+                return new Subscriber(observer) {
+                    private R value = initialValue;
+
+                    @Override
+                    public void onNext(T value) {
+                        try {
+                            this.value = accumulator.call(this.value, value);
+                        } catch (Throwable e) {
+                            observer.onError(e);
+                            observer.unsubscribe();
+                        }
+                        observer.onNext(this.value);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        observer.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        observer.onCompleted();
+                    }
+                };
+            }
+        };
     }
 
     /**
-     * Applies an accumulator function over an observable sequence and returns each intermediate result with the specified source and accumulator.
+     * Applies an accumulator function over an observable sequence and returns each intermediate
+     * result with the specified source and accumulator.
      * 
      * @param sequence
      *            An observable sequence of elements to project.
      * @param accumulator
      *            An accumulator function to be invoked on each element from the sequence.
      * 
-     * @return An observable sequence whose elements are the result of accumulating the output from the list of Observables.
-     * @see Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))
+     * @return An observable sequence whose elements are the result of accumulating the output from
+     *         the list of Observables.
+     * @see Observable.Scan(TSource)
+     *      Method (IObservable(TSource), Func(TSource, TSource, TSource))
      */
-    public static  OnSubscribeFunc scan(Observable sequence, Func2 accumulator) {
-        return new AccuWithoutInitialValue(sequence, accumulator);
-    }
-
-    private static class AccuWithoutInitialValue implements OnSubscribeFunc {
-        private final Observable sequence;
-        private final Func2 accumulatorFunction;
-
-        private AccumulatingObserver accumulatingObserver;
-
-        private AccuWithoutInitialValue(Observable sequence, Func2 accumulator) {
-            this.sequence = sequence;
-            this.accumulatorFunction = accumulator;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            return sequence.subscribe(new Observer() {
-
-                // has to be synchronized so that the initial value is always sent only once.
-                @Override
-                public synchronized void onNext(T value) {
-                    if (accumulatingObserver == null) {
-                        observer.onNext(value);
-                        accumulatingObserver = new AccumulatingObserver(observer, value, accumulatorFunction);
-                    } else {
-                        accumulatingObserver.onNext(value);
+    public static  Operator scan(final Func2 accumulator) {
+        return new Operator() {
+            @Override
+            public Subscriber call(final Subscriber observer) {
+                return new Subscriber(observer) {
+                    private boolean first = true;
+                    private T value;
+
+                    @Override
+                    public void onNext(T value) {
+                        if (first) {
+                            this.value = value;
+                            first = false;
+                        }
+                        else {
+                            try {
+                                this.value = accumulator.call(this.value, value);
+                            } catch (Throwable e) {
+                                observer.onError(e);
+                                observer.unsubscribe();
+                            }
+                        }
+                        observer.onNext(this.value);
                     }
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
-                }
 
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-            });
-        }
-    }
-
-    private static class Accumulator implements OnSubscribeFunc {
-        private final Observable sequence;
-        private final R initialValue;
-        private final Func2 accumulatorFunction;
-
-        private Accumulator(Observable sequence, R initialValue, Func2 accumulator) {
-            this.sequence = sequence;
-            this.initialValue = initialValue;
-            this.accumulatorFunction = accumulator;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer observer) {
-            observer.onNext(initialValue);
-            return sequence.subscribe(new AccumulatingObserver(observer, initialValue, accumulatorFunction));
-        }
-    }
-
-    private static class AccumulatingObserver implements Observer {
-        private final Observer observer;
-        private final Func2 accumulatorFunction;
-
-        private R acc;
-
-        private AccumulatingObserver(Observer observer, R initialValue, Func2 accumulator) {
-            this.observer = observer;
-            this.accumulatorFunction = accumulator;
-
-            this.acc = initialValue;
-        }
+                    @Override
+                    public void onError(Throwable e) {
+                        observer.onError(e);
+                    }
 
-        /**
-         * We must synchronize this because we can't allow
-         * multiple threads to execute the 'accumulatorFunction' at the same time because
-         * the accumulator code very often will be doing mutation of the 'acc' object such as a non-threadsafe HashMap
-         * 
-         * Because it's synchronized it's using non-atomic variables since everything in this method is single-threaded
-         */
-        @Override
-        public synchronized void onNext(T value) {
-            try {
-                acc = accumulatorFunction.call(acc, value);
-                observer.onNext(acc);
-            } catch (Throwable ex) {
-                observer.onError(ex);
+                    @Override
+                    public void onCompleted() {
+                        observer.onCompleted();
+                    }
+                };
             }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            observer.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            observer.onCompleted();
-        }
+        };
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
index 4a12335e42..65d4c8e4a9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSum.java
@@ -16,291 +16,74 @@
 package rx.operators;
 
 import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
-import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
 /**
  * A few operators for implementing the sum operation.
  * 
- * @see MSDN: Observable.Sum
+ * @see MSDN:
+ *      Observable.Sum
  */
 public final class OperationSum {
-    public static Observable sum(Observable source) {
-        return source.reduce(0, new Func2() {
-            @Override
-            public Integer call(Integer accu, Integer next) {
-                return accu + next;
-            }
-        });
+
+    public static Observable sumIntegers(Observable source) {
+        return source.reduce(0, ACCUM_INT);
     }
 
     public static Observable sumLongs(Observable source) {
-        return source.reduce(0L, new Func2() {
-            @Override
-            public Long call(Long accu, Long next) {
-                return accu + next;
-            }
-        });
+        return source.reduce(0l, ACCUM_LONG);
     }
 
     public static Observable sumFloats(Observable source) {
-        return source.reduce(0.0f, new Func2() {
-            @Override
-            public Float call(Float accu, Float next) {
-                return accu + next;
-            }
-        });
+        return source.reduce(0.0f, ACCUM_FLOAT);
     }
 
     public static Observable sumDoubles(Observable source) {
-        return source.reduce(0.0d, new Func2() {
-            @Override
-            public Double call(Double accu, Double next) {
-                return accu + next;
-            }
-        });
+        return source.reduce(0.0d, ACCUM_DOUBLE);
     }
 
-    /**
-     * Compute the sum by extracting integer values from the source via an
-     * extractor function.
-     * 
-     * @param 
-     *            the source value type
-     */
-    public static final class SumIntegerExtractor implements Observable.OnSubscribeFunc {
-        final Observable source;
-        final Func1 valueExtractor;
-
-        public SumIntegerExtractor(Observable source, Func1 valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new SumObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class SumObserver implements Observer {
-            final Observer observer;
-            int sum;
-            boolean hasValue;
-
-            public SumObserver(Observer observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onNext(T args) {
-                sum += valueExtractor.call(args);
-                hasValue = true;
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                if (hasValue) {
-                    try {
-                        observer.onNext(sum);
-                    } catch (Throwable t) {
-                        observer.onError(t);
-                        return;
-                    }
-                    observer.onCompleted();
-                } else {
-                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
-                }
-            }
-
-        }
+    public static Observable sumAtLeastOneIntegers(Observable source) {
+        return source.reduce(ACCUM_INT);
     }
 
-    /**
-     * Compute the sum by extracting long values from the source via an
-     * extractor function.
-     * 
-     * @param 
-     *            the source value type
-     */
-    public static final class SumLongExtractor implements Observable.OnSubscribeFunc {
-        final Observable source;
-        final Func1 valueExtractor;
-
-        public SumLongExtractor(Observable source, Func1 valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new SumObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class SumObserver implements Observer {
-            final Observer observer;
-            long sum;
-            boolean hasValue;
-
-            public SumObserver(Observer observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onNext(T args) {
-                sum += valueExtractor.call(args);
-                hasValue = true;
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                if (hasValue) {
-                    try {
-                        observer.onNext(sum);
-                    } catch (Throwable t) {
-                        observer.onError(t);
-                        return;
-                    }
-                    observer.onCompleted();
-                } else {
-                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
-                }
-            }
-
-        }
+    public static Observable sumAtLeastOneLongs(Observable source) {
+        return source.reduce(ACCUM_LONG);
     }
 
-    /**
-     * Compute the sum by extracting float values from the source via an
-     * extractor function.
-     * 
-     * @param 
-     *            the source value type
-     */
-    public static final class SumFloatExtractor implements Observable.OnSubscribeFunc {
-        final Observable source;
-        final Func1 valueExtractor;
+    public static Observable sumAtLeastOneFloats(Observable source) {
+        return source.reduce(ACCUM_FLOAT);
+    }
 
-        public SumFloatExtractor(Observable source, Func1 valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
+    public static Observable sumAtLeastOneDoubles(Observable source) {
+        return source.reduce(ACCUM_DOUBLE);
+    }
 
+    private static final Func2 ACCUM_INT = new Func2() {
         @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new SumObserver(t1));
+        public Integer call(Integer accu, Integer next) {
+            return accu + next;
         }
+    };
 
-        /** Computes the average. */
-        private final class SumObserver implements Observer {
-            final Observer observer;
-            float sum;
-            boolean hasValue;
-
-            public SumObserver(Observer observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onNext(T args) {
-                sum += valueExtractor.call(args);
-                hasValue = true;
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                if (hasValue) {
-                    try {
-                        observer.onNext(sum);
-                    } catch (Throwable t) {
-                        observer.onError(t);
-                        return;
-                    }
-                    observer.onCompleted();
-                } else {
-                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
-                }
-            }
-
-        }
-    }
-
-    /**
-     * Compute the sum by extracting float values from the source via an
-     * extractor function.
-     * 
-     * @param 
-     *            the source value type
-     */
-    public static final class SumDoubleExtractor implements Observable.OnSubscribeFunc {
-        final Observable source;
-        final Func1 valueExtractor;
-
-        public SumDoubleExtractor(Observable source, Func1 valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
+    private static final Func2 ACCUM_LONG = new Func2() {
+        @Override
+        public Long call(Long accu, Long next) {
+            return accu + next;
         }
+    };
 
+    private static final Func2 ACCUM_FLOAT = new Func2() {
         @Override
-        public Subscription onSubscribe(Observer t1) {
-            return source.subscribe(new SumObserver(t1));
+        public Float call(Float accu, Float next) {
+            return accu + next;
         }
+    };
 
-        /** Computes the average. */
-        private final class SumObserver implements Observer {
-            final Observer observer;
-            double sum;
-            boolean hasValue;
-
-            public SumObserver(Observer observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onNext(T args) {
-                sum += valueExtractor.call(args);
-                hasValue = true;
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                if (hasValue) {
-                    try {
-                        observer.onNext(sum);
-                    } catch (Throwable t) {
-                        observer.onError(t);
-                        return;
-                    }
-                    observer.onCompleted();
-                } else {
-                    observer.onError(new IllegalArgumentException("Sequence contains no elements"));
-                }
-            }
-
+    private static final Func2 ACCUM_DOUBLE = new Func2() {
+        @Override
+        public Double call(Double accu, Double next) {
+            return accu + next;
         }
-    }
-
+    };
 }
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 20d1b8811c..8704f80d61 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -52,7 +52,7 @@ public Movie call(Movie t1, Movie t2) {
                     }
                 };
 
-        Observable reduceResult = Observable.create(OperationScan.scan(horrorMovies, chooseSecondMovie)).takeLast(1);
+        Observable reduceResult = horrorMovies.lift(OperationScan.scan(chooseSecondMovie)).takeLast(1);
 
         Observable reduceResult2 = horrorMovies.reduce(chooseSecondMovie);
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java b/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
index 47a3274e52..2e1613353b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
@@ -41,7 +41,7 @@ public void testScanIntegersWithInitialValue() {
 
         Observable observable = Observable.from(1, 2, 3);
 
-        Observable m = Observable.create(scan(observable, "", new Func2() {
+        Observable m = observable.lift(scan("", new Func2() {
 
             @Override
             public String call(String s, Integer n) {
@@ -68,7 +68,7 @@ public void testScanIntegersWithoutInitialValue() {
 
         Observable observable = Observable.from(1, 2, 3);
 
-        Observable m = Observable.create(scan(observable, new Func2() {
+        Observable m = observable.lift(scan(new Func2() {
 
             @Override
             public Integer call(Integer t1, Integer t2) {
@@ -95,7 +95,7 @@ public void testScanIntegersWithoutInitialValueAndOnlyOneValue() {
 
         Observable observable = Observable.from(1);
 
-        Observable m = Observable.create(scan(observable, new Func2() {
+        Observable m = observable.lift(scan(new Func2() {
 
             @Override
             public Integer call(Integer t1, Integer t2) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index 478158eb21..7253e6196f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -39,7 +39,7 @@ public class OperationSumTest {
     @Test
     public void testSumOfAFewInts() throws Throwable {
         Observable src = Observable.from(1, 2, 3, 4, 5);
-        sum(src).subscribe(w);
+        sumIntegers(src).subscribe(w);
 
         verify(w, times(1)).onNext(anyInt());
         verify(w).onNext(15);
@@ -50,7 +50,7 @@ public void testSumOfAFewInts() throws Throwable {
     @Test
     public void testEmptySum() throws Throwable {
         Observable src = Observable.empty();
-        sum(src).subscribe(w);
+        sumIntegers(src).subscribe(w);
 
         verify(w, times(1)).onNext(anyInt());
         verify(w).onNext(0);

From 13d293fb4a3298b4084008a4e920d2a8c31c6283 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 12 Feb 2014 13:20:08 -0800
Subject: [PATCH 387/441] Update OperationScan to OperatorScan

Migrate to use updated conventions of Operator* classes that implement rx.Observable.Operator
---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../main/java/rx/operators/OperationScan.java | 140 ------------------
 .../main/java/rx/operators/OperatorScan.java  | 117 +++++++++++++++
 rxjava-core/src/test/java/rx/ReduceTests.java |   4 +-
 ...ionScanTest.java => OperatorScanTest.java} |  16 +-
 5 files changed, 130 insertions(+), 153 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationScan.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorScan.java
 rename rxjava-core/src/test/java/rx/operators/{OperationScanTest.java => OperatorScanTest.java} (89%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index a5a265fa8b..cb5b82fd46 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -72,7 +72,7 @@
 import rx.operators.OperationReplay;
 import rx.operators.OperationRetry;
 import rx.operators.OperationSample;
-import rx.operators.OperationScan;
+import rx.operators.OperatorScan;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSingle;
 import rx.operators.OperationSkip;
@@ -6140,7 +6140,7 @@ public final  Observable sample(Observable sampler) {
      * @see MSDN: Observable.Scan
      */
     public final Observable scan(Func2 accumulator) {
-        return lift(OperationScan.scan(accumulator));
+        return lift(new OperatorScan(accumulator));
     }
 
     /**
@@ -6167,7 +6167,7 @@ public final Observable scan(Func2 accumulator) {
      * @see MSDN: Observable.Scan
      */
     public final  Observable scan(R initialValue, Func2 accumulator) {
-        return lift(OperationScan.scan(initialValue, accumulator));
+        return lift(new OperatorScan(initialValue, accumulator));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationScan.java b/rxjava-core/src/main/java/rx/operators/OperationScan.java
deleted file mode 100644
index 8bbaeb0e59..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationScan.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * Copyright 2014 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 rx.Observable.Operator;
-import rx.Subscriber;
-import rx.util.functions.Func2;
-
-/**
- * Returns an Observable that applies a function 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.
- */
-public final class OperationScan {
-    /**
-     * Applies an accumulator function over an observable sequence and returns each intermediate
-     * result with the specified source and accumulator.
-     * 
-     * @param sequence
-     *            An observable sequence of elements to project.
-     * @param initialValue
-     *            The initial (seed) accumulator value.
-     * @param accumulator
-     *            An accumulator function to be invoked on each element from the sequence.
-     * 
-     * @return An observable sequence whose elements are the result of accumulating the output from
-     *         the list of Observables.
-     * @see Observable.Scan(TSource,
-     *      TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
-     *      TAccumulate))
-     */
-    public static  Operator scan(final R initialValue, final Func2 accumulator) {
-        return new Operator() {
-            @Override
-            public Subscriber call(final Subscriber observer) {
-                observer.onNext(initialValue);
-                return new Subscriber(observer) {
-                    private R value = initialValue;
-
-                    @Override
-                    public void onNext(T value) {
-                        try {
-                            this.value = accumulator.call(this.value, value);
-                        } catch (Throwable e) {
-                            observer.onError(e);
-                            observer.unsubscribe();
-                        }
-                        observer.onNext(this.value);
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        observer.onError(e);
-                    }
-
-                    @Override
-                    public void onCompleted() {
-                        observer.onCompleted();
-                    }
-                };
-            }
-        };
-    }
-
-    /**
-     * Applies an accumulator function over an observable sequence and returns each intermediate
-     * result with the specified source and accumulator.
-     * 
-     * @param sequence
-     *            An observable sequence of elements to project.
-     * @param accumulator
-     *            An accumulator function to be invoked on each element from the sequence.
-     * 
-     * @return An observable sequence whose elements are the result of accumulating the output from
-     *         the list of Observables.
-     * @see Observable.Scan(TSource)
-     *      Method (IObservable(TSource), Func(TSource, TSource, TSource))
-     */
-    public static  Operator scan(final Func2 accumulator) {
-        return new Operator() {
-            @Override
-            public Subscriber call(final Subscriber observer) {
-                return new Subscriber(observer) {
-                    private boolean first = true;
-                    private T value;
-
-                    @Override
-                    public void onNext(T value) {
-                        if (first) {
-                            this.value = value;
-                            first = false;
-                        }
-                        else {
-                            try {
-                                this.value = accumulator.call(this.value, value);
-                            } catch (Throwable e) {
-                                observer.onError(e);
-                                observer.unsubscribe();
-                            }
-                        }
-                        observer.onNext(this.value);
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        observer.onError(e);
-                    }
-
-                    @Override
-                    public void onCompleted() {
-                        observer.onCompleted();
-                    }
-                };
-            }
-        };
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
new file mode 100644
index 0000000000..c3b4a3d22d
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -0,0 +1,117 @@
+/**
+ * Copyright 2014 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 rx.Observable.Operator;
+import rx.Subscriber;
+import rx.util.functions.Func2;
+
+/**
+ * Returns an Observable that applies a function 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.
+ */
+public final class OperatorScan implements Operator {
+
+    private final R initialValue;
+    private final Func2 accumulator;
+    // sentinel if we don't receive an initial value
+    private static final Object NO_INITIAL_VALUE = new Object();
+
+    /**
+     * Applies an accumulator function over an observable sequence and returns each intermediate
+     * result with the specified source and accumulator.
+     * 
+     * @param sequence
+     *            An observable sequence of elements to project.
+     * @param initialValue
+     *            The initial (seed) accumulator value.
+     * @param accumulator
+     *            An accumulator function to be invoked on each element from the sequence.
+     * 
+     * @return An observable sequence whose elements are the result of accumulating the output from
+     *         the list of Observables.
+     * @see Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
+     *      TAccumulate))
+     */
+    public OperatorScan(R initialValue, Func2 accumulator) {
+        this.initialValue = initialValue;
+        this.accumulator = accumulator;
+    }
+
+    /**
+     * Applies an accumulator function over an observable sequence and returns each intermediate
+     * result with the specified source and accumulator.
+     * 
+     * @param sequence
+     *            An observable sequence of elements to project.
+     * @param accumulator
+     *            An accumulator function to be invoked on each element from the sequence.
+     * 
+     * @return An observable sequence whose elements are the result of accumulating the output from
+     *         the list of Observables.
+     * @see Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))
+     */
+    @SuppressWarnings("unchecked")
+    public OperatorScan(final Func2 accumulator) {
+        this((R) NO_INITIAL_VALUE, accumulator);
+    }
+
+    @Override
+    public Subscriber call(final Subscriber observer) {
+        if (initialValue != NO_INITIAL_VALUE) {
+            observer.onNext(initialValue);
+        }
+        return new Subscriber(observer) {
+            private R value = initialValue;
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public void onNext(T value) {
+                if (this.value == NO_INITIAL_VALUE) {
+                    // if there is NO_INITIAL_VALUE then we know it is type T for both so cast T to R
+                    this.value = (R) value;
+                } else {
+                    try {
+                        this.value = accumulator.call(this.value, value);
+                    } catch (Throwable e) {
+                        observer.onError(e);
+                        observer.unsubscribe();
+                    }
+                }
+                observer.onNext(this.value);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                observer.onCompleted();
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 8704f80d61..63cce95c2f 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -21,7 +21,7 @@
 
 import rx.CovarianceTest.HorrorMovie;
 import rx.CovarianceTest.Movie;
-import rx.operators.OperationScan;
+import rx.operators.OperatorScan;
 import rx.util.functions.Func2;
 
 public class ReduceTests {
@@ -52,7 +52,7 @@ public Movie call(Movie t1, Movie t2) {
                     }
                 };
 
-        Observable reduceResult = horrorMovies.lift(OperationScan.scan(chooseSecondMovie)).takeLast(1);
+        Observable reduceResult = horrorMovies.scan(chooseSecondMovie).takeLast(1);
 
         Observable reduceResult2 = horrorMovies.reduce(chooseSecondMovie);
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
similarity index 89%
rename from rxjava-core/src/test/java/rx/operators/OperationScanTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
index 2e1613353b..0a653af315 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
@@ -17,7 +17,7 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationScan.*;
+import static rx.operators.OperatorScan.*;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -27,7 +27,7 @@
 import rx.Observer;
 import rx.util.functions.Func2;
 
-public class OperationScanTest {
+public class OperatorScanTest {
 
     @Before
     public void before() {
@@ -41,14 +41,14 @@ public void testScanIntegersWithInitialValue() {
 
         Observable observable = Observable.from(1, 2, 3);
 
-        Observable m = observable.lift(scan("", new Func2() {
+        Observable m = observable.scan("", new Func2() {
 
             @Override
             public String call(String s, Integer n) {
                 return s + n.toString();
             }
 
-        }));
+        });
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -68,14 +68,14 @@ public void testScanIntegersWithoutInitialValue() {
 
         Observable observable = Observable.from(1, 2, 3);
 
-        Observable m = observable.lift(scan(new Func2() {
+        Observable m = observable.scan(new Func2() {
 
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
 
-        }));
+        });
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -95,14 +95,14 @@ public void testScanIntegersWithoutInitialValueAndOnlyOneValue() {
 
         Observable observable = Observable.from(1);
 
-        Observable m = observable.lift(scan(new Func2() {
+        Observable m = observable.scan(new Func2() {
 
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
 
-        }));
+        });
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));

From cb5b5fb59b528951ccd14e7c5d7cc51d35457cfa Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 12 Feb 2014 16:49:51 -0800
Subject: [PATCH 388/441] 
 TestSubscriber.awaitTerminalEventAndUnsubscribeOnTimeout

---
 rxjava-core/src/main/java/rx/Observable.java              | 1 +
 .../src/main/java/rx/observers/TestSubscriber.java        | 8 ++++++++
 2 files changed, 9 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0b095cb14f..297e547b27 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7057,6 +7057,7 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
     public final Observable subscribeOn(Scheduler scheduler) {
         return nest().lift(new OperatorSubscribeOn(scheduler, false));
     }
+    
     /**
      * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified {@link Scheduler}
      * and allows buffering some events emitted from the source in the time gap between the original and
diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index ff875b2655..bf51a2b5b4 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -101,6 +101,14 @@ public void awaitTerminalEvent(long timeout, TimeUnit unit) {
         }
     }
 
+    public void awaitTerminalEventAndUnsubscribeOnTimeout(long timeout, TimeUnit unit) {
+        try {
+            awaitTerminalEvent(timeout, unit);
+        } catch (RuntimeException e) {
+            unsubscribe();
+        }
+    }
+
     public Thread getLastSeenThread() {
         return lastSeenThread;
     }

From a394a7d8e91a4adc05642a2d54b5b2f97402be28 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 12 Feb 2014 16:59:41 -0800
Subject: [PATCH 389/441] GroupBy and SubscribeOn Tests Passing

---
 .../rx/operators/OperatorSubscribeOn.java     | 118 ++++++------
 .../rx/operators/OperatorGroupByTest.java     |   7 +-
 .../rx/operators/OperatorSubscribeOnTest.java | 173 ++++++++++--------
 3 files changed, 156 insertions(+), 142 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 55bef3bfdb..a735886b5c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -22,35 +22,44 @@
 import rx.Subscriber;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
- * Asynchronously subscribes and unsubscribes Observers on the specified Scheduler.
+ * Subscribes and unsubscribes Observers on the specified Scheduler.
  * 
    
+ * Will occur asynchronously except when subscribing to `GroupedObservable`, `PublishSubject` and possibly other "hot" Observables
+ * in which case it will subscribe synchronously and buffer/block onNext calls until the subscribe has occurred.
+ * 
    
+ * See https://github.com/Netflix/RxJava/issues/844 for more information on the "time gap" issue that the synchronous
+ * subscribe is solving.
+ * 
  * 
  */
 public class OperatorSubscribeOn implements Operator> {
 
     private final Scheduler scheduler;
-    /** 
+    /**
      * Indicate that events fired between the original subscription time and
      * the actual subscription time should not get lost.
      */
     private final boolean dontLoseEvents;
     /** The buffer size to avoid flooding. Negative value indicates an unbounded buffer. */
     private final int bufferSize;
+
     public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
         this(scheduler, dontLoseEvents, -1);
     }
+
     /**
      * Construct a SubscribeOn operator.
-     * @param scheduler the target scheduler
-     * @param dontLoseEvents indicate that events should be buffered until the actual subscription happens
-     * @param bufferSize if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
-     * block the source. -1 indicates an unbounded buffer
+     * 
+     * @param scheduler
+     *            the target scheduler
+     * @param dontLoseEvents
+     *            indicate that events should be buffered until the actual subscription happens
+     * @param bufferSize
+     *            if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
+     *            block the source. -1 indicates an unbounded buffer
      */
     public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents, int bufferSize) {
         this.scheduler = scheduler;
@@ -71,78 +80,61 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 subscriber.onError(e);
             }
+
             boolean checkNeedBuffer(Observable o) {
-                return dontLoseEvents || ((o instanceof GroupedObservable)
+                /*
+                 * Included are some Observable types known to be "hot" and thus needing
+                 * buffering when subscribing across thread boundaries otherwise
+                 * we can lose data.
+                 * 
+                 * See https://github.com/Netflix/RxJava/issues/844 for more information.
+                 */
+                return dontLoseEvents
+                        || ((o instanceof GroupedObservable)
                         || (o instanceof PublishSubject)
                         // || (o instanceof BehaviorSubject)
                         );
             }
+
             @Override
             public void onNext(final Observable o) {
                 if (checkNeedBuffer(o)) {
-                    final CompositeSubscription cs = new CompositeSubscription();
-                    subscriber.add(cs);
-                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(bufferSize, subscriber, new CompositeSubscription());
+                    // use buffering (possibly blocking) for a possibly synchronous subscribe
+                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(bufferSize, subscriber);
                     o.subscribe(bus);
-                    scheduler.schedule(new Action1() {
+                    subscriber.add(scheduler.schedule(new Action1() {
                         @Override
                         public void call(final Inner inner) {
-                            cs.add(Subscriptions.create(new Action0() {
-                                @Override
-                                public void call() {
-                                    inner.schedule(new Action1() {
-                                        @Override
-                                        public void call(final Inner inner) {
-                                            bus.unsubscribe();
-                                        }
-                                    });
-                                }
-                            }));
                             bus.enterPassthroughMode();
                         }
-                    });
+                    }));
                     return;
-                }
-                scheduler.schedule(new Action1() {
-
-                    @Override
-                    public void call(final Inner inner) {
-                        final CompositeSubscription cs = new CompositeSubscription();
-                        subscriber.add(Subscriptions.create(new Action0() {
-
-                            @Override
-                            public void call() {
-                                inner.schedule(new Action1() {
-
-                                    @Override
-                                    public void call(final Inner inner) {
-                                        cs.unsubscribe();
-                                    }
-
-                                });
-                            }
+                } else {
+                    // no buffering (async subscribe)
+                    scheduler.schedule(new Action1() {
 
-                        }));
-                        cs.add(subscriber);
-                        o.subscribe(new Subscriber(cs) {
+                        @Override
+                        public void call(final Inner inner) {
+                            o.subscribe(new Subscriber(subscriber) {
 
-                            @Override
-                            public void onCompleted() {
-                                subscriber.onCompleted();
-                            }
+                                @Override
+                                public void onCompleted() {
+                                    subscriber.onCompleted();
+                                }
 
-                            @Override
-                            public void onError(Throwable e) {
-                                subscriber.onError(e);
-                            }
+                                @Override
+                                public void onError(Throwable e) {
+                                    subscriber.onError(e);
+                                }
 
-                            @Override
-                            public void onNext(T t) {
-                                subscriber.onNext(t);
-                            }
-                        });
-                    }
-                });
+                                @Override
+                                public void onNext(T t) {
+                                    subscriber.onNext(t);
+                                }
+                            });
+                        }
+                    });
+                }
             }
 
         };
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 7fc1207208..ba6871e314 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -253,7 +253,6 @@ public void testUnsubscribeOnNestedTakeAndSyncInfiniteStream() throws Interrupte
     /*
      * We will only take 1 group with 20 events from it and then unsubscribe.
      */
-    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testUnsubscribeOnNestedTakeAndAsyncInfiniteStream() throws InterruptedException {
         final AtomicInteger subscribeCounter = new AtomicInteger();
@@ -648,7 +647,6 @@ public void call(String s) {
         assertEquals(6, results.size());
     }
 
-    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
@@ -702,7 +700,7 @@ public void call() {
 
                             });
                 } else {
-                    return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+                    return group.subscribeOn(Schedulers.newThread(), 1).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
 
                         @Override
                         public String call(Integer t1) {
@@ -803,7 +801,6 @@ public void call(String s) {
         assertEquals(6, results.size());
     }
 
-    @Ignore // failing because of subscribeOn time gap issue: https://github.com/Netflix/RxJava/issues/844
     @Test
     public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
         final ArrayList results = new ArrayList();
@@ -829,7 +826,7 @@ public Integer call(Integer t) {
 
             @Override
             public Observable call(final GroupedObservable group) {
-                return group.subscribeOn(Schedulers.newThread()).map(new Func1() {
+                return group.subscribeOn(Schedulers.newThread(), 0).map(new Func1() {
 
                     @Override
                     public String call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index b05b7724f8..ddf883b07b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -1,37 +1,36 @@
- /**
-  * Copyright 2014 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.
-  */
+/**
+ * Copyright 2014 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 java.util.ArrayList;
 import static org.junit.Assert.*;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
-import org.junit.Ignore;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.observables.GroupedObservable;
@@ -39,8 +38,6 @@
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.Timestamped;
 import rx.util.functions.Action0;
@@ -48,45 +45,45 @@
 import rx.util.functions.Func1;
 
 public class OperatorSubscribeOnTest {
-    
+
     private class ThreadSubscription implements Subscription {
         private volatile Thread thread;
-        
+
         private final CountDownLatch latch = new CountDownLatch(1);
-        
+
         private final Subscription s = Subscriptions.create(new Action0() {
-            
+
             @Override
             public void call() {
                 thread = Thread.currentThread();
                 latch.countDown();
             }
-            
+
         });
-        
+
         @Override
         public void unsubscribe() {
             s.unsubscribe();
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return s.isUnsubscribed();
         }
-        
+
         public Thread getThread() throws InterruptedException {
             latch.await();
             return thread;
         }
     }
-    
+
     @Test
     public void testSubscribeOnAndVerifySubscribeAndUnsubscribeThreads()
             throws InterruptedException {
         final ThreadSubscription subscription = new ThreadSubscription();
         final AtomicReference subscribeThread = new AtomicReference();
         Observable w = Observable.create(new OnSubscribe() {
-            
+
             @Override
             public void call(Subscriber t1) {
                 subscribeThread.set(Thread.currentThread());
@@ -96,33 +93,33 @@ public void call(Subscriber t1) {
                 t1.onCompleted();
             }
         });
-        
+
         TestObserver observer = new TestObserver();
         w.subscribeOn(Schedulers.newThread()).subscribe(observer);
-        
+
         Thread unsubscribeThread = subscription.getThread();
-        
+
         assertNotNull(unsubscribeThread);
         assertNotSame(Thread.currentThread(), unsubscribeThread);
-        
+
         assertNotNull(subscribeThread.get());
         assertNotSame(Thread.currentThread(), subscribeThread.get());
         // True for Schedulers.newThread()
         assertTrue(unsubscribeThread == subscribeThread.get());
-        
+
         observer.assertReceivedOnNext(Arrays.asList(1, 2));
         observer.assertTerminalEvent();
     }
-    
+
     @Test
     public void testIssue813() throws InterruptedException {
         // https://github.com/Netflix/RxJava/issues/813
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch doneLatch = new CountDownLatch(1);
-        
+
         TestObserver observer = new TestObserver();
         final ThreadSubscription s = new ThreadSubscription();
-        
+
         final Subscription subscription = Observable
                 .create(new Observable.OnSubscribe() {
                     @Override
@@ -147,7 +144,7 @@ public void call(
                         }
                     }
                 }).subscribeOn(Schedulers.computation()).subscribe(observer);
-        
+
         subscription.unsubscribe();
         // As unsubscribe is called in other thread, we need to wait for it.
         s.getThread();
@@ -156,14 +153,16 @@ public void call(
         assertEquals(0, observer.getOnErrorEvents().size());
         assertEquals(1, observer.getOnCompletedEvents().size());
     }
-    
+
     public static class SlowScheduler extends Scheduler {
         final Scheduler actual;
         final long delay;
         final TimeUnit unit;
+
         public SlowScheduler() {
             this(Schedulers.computation(), 2, TimeUnit.SECONDS);
         }
+
         public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
             this.actual = actual;
             this.delay = delay;
@@ -182,7 +181,7 @@ public Subscription schedule(final Action1 action, final long d
             return actual.schedule(action, t, common);
         }
     }
-    
+
     @Test
     public void testSubscribeOnPublishSubjectWithSlowScheduler() {
         PublishSubject ps = PublishSubject.create();
@@ -191,16 +190,16 @@ public void testSubscribeOnPublishSubjectWithSlowScheduler() {
         ps.onNext(1);
         ps.onNext(2);
         ps.onCompleted();
-        
+
         ts.awaitTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
     }
-    
+
     @Test
     public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
         final ArrayList results = new ArrayList();
         Observable.create(new OnSubscribe() {
-            
+
             @Override
             public void call(Subscriber sub) {
                 sub.onNext(1);
@@ -209,48 +208,48 @@ public void call(Subscriber sub) {
                 sub.onNext(2);
                 sub.onCompleted();
             }
-            
+
         }).groupBy(new Func1() {
-            
+
             @Override
             public Integer call(Integer t) {
                 return t;
             }
-            
+
         }).flatMap(new Func1, Observable>() {
-            
+
             @Override
             public Observable call(final GroupedObservable group) {
                 return group.subscribeOn(Schedulers.newThread()).map(new Func1() {
-                    
+
                     @Override
                     public String call(Integer t1) {
                         System.out.println("Received: " + t1 + " on group : " + group.getKey());
                         return "first groups: " + t1;
                     }
-                    
+
                 });
             }
-            
+
         }).toBlockingObservable().forEach(new Action1() {
-            
+
             @Override
             public void call(String s) {
                 results.add(s);
             }
-            
+
         });
-        
+
         System.out.println("Results: " + results);
         assertEquals(4, results.size());
     }
-    
+
     @Test
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
         final ArrayList results = new ArrayList();
         Observable.create(new OnSubscribe() {
-            
+
             @Override
             public void call(Subscriber sub) {
                 sub.onNext(1);
@@ -267,65 +266,66 @@ public void call(Subscriber sub) {
                 sub.onNext(3);
                 sub.onCompleted();
             }
-            
+
         }).groupBy(new Func1() {
-            
+
             @Override
             public Integer call(Integer t) {
                 return t;
             }
-            
+
         }).flatMap(new Func1, Observable>() {
-            
+
             @Override
             public Observable call(final GroupedObservable group) {
                 if (group.getKey() < 3) {
                     return group.map(new Func1() {
-                        
+
                         @Override
                         public String call(Integer t1) {
                             return "first groups: " + t1;
                         }
-                        
+
                     })
                             // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
                             .take(2).doOnCompleted(new Action0() {
-                                
+
                                 @Override
                                 public void call() {
                                     first.countDown();
                                 }
-                                
+
                             });
                 } else {
                     return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
-                        
+
                         @Override
                         public String call(Integer t1) {
                             return "last group: " + t1;
                         }
-                        
+
                     });
                 }
             }
-            
+
         }).toBlockingObservable().forEach(new Action1() {
-            
+
             @Override
             public void call(String s) {
                 results.add(s);
             }
-            
+
         });
-        
+
         System.out.println("Results: " + results);
         assertEquals(6, results.size());
     }
+
     void testBoundedBufferingWithSize(int size) throws Exception {
         Observable timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS);
 
         final List deltas = Collections.synchronizedList(new ArrayList());
-        
+
         Subscription s = timer.timestamp().subscribeOn(
                 new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size).map(new Func1, Long>() {
             @Override
@@ -339,11 +339,11 @@ public void call(Long t1) {
                 deltas.add(t1);
             }
         }).subscribe();
-        
+
         Thread.sleep(2050);
-        
+
         s.unsubscribe();
-        
+
         if (deltas.size() < size + 1) {
             fail("To few items in deltas: " + deltas);
         }
@@ -358,16 +358,41 @@ public void call(Long t1) {
             }
         }
     }
+
     @Test(timeout = 5000)
     public void testBoundedBufferingOfZero() throws Exception {
         testBoundedBufferingWithSize(0);
     }
+
     @Test(timeout = 5000)
     public void testBoundedBufferingOfOne() throws Exception {
         testBoundedBufferingWithSize(1);
     }
+
     @Test(timeout = 5000)
     public void testBoundedBufferingOfTwo() throws Exception {
         testBoundedBufferingWithSize(2);
     }
+
+    @Test(timeout = 5000)
+    public void testUnsubscribeInfiniteStream() throws InterruptedException {
+        TestSubscriber ts = new TestSubscriber();
+        final AtomicInteger count = new AtomicInteger();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                for (int i = 1; !sub.isUnsubscribed(); i++) {
+                    count.incrementAndGet();
+                    sub.onNext(i);
+                }
+            }
+
+        }).subscribeOn(Schedulers.newThread()).take(10).subscribe(ts);
+
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(1000, TimeUnit.MILLISECONDS);
+        Thread.sleep(200); // give time for the loop to continue
+        ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+        assertEquals(10, count.get());
+    }
 }

From c9588bdaf7b961e0cd1c8eb9fc2510e5f2e431b9 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Thu, 13 Feb 2014 18:05:46 +0800
Subject: [PATCH 390/441] Add the selector variants of timeout in RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 21 ++++
 .../main/scala/rx/lang/scala/Observable.scala | 96 +++++++++++++++++++
 rxjava-core/src/main/java/rx/Observable.java  |  8 +-
 3 files changed, 121 insertions(+), 4 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
index 9bd2ed7120..6b6faf4f7d 100644
--- a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
+++ b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
@@ -474,4 +474,25 @@ class RxScalaDemo extends JUnitSuite {
     obs.toBlockingObservable.toIterable.last
   }
 
+  @Test def timeoutExample(): Unit = {
+    val other = List(100L, 200L, 300L).toObservable
+    val result = Observable.interval(100 millis).timeout(50 millis, other).toBlockingObservable.toList
+    println(result)
+  }
+
+  @Test def timeoutExample2(): Unit = {
+    val firstTimeoutSelector = () => {
+      Observable.timer(10 seconds, 10 seconds, ComputationScheduler()).take(1)
+    }
+    val timeoutSelector = (t: Long) => {
+      Observable.timer(
+        (500 - t * 100) max 1 millis,
+        (500 - t * 100) max 1 millis,
+        ComputationScheduler()).take(1)
+    }
+    val other = List(100L, 200L, 300L).toObservable
+    val result = Observable.interval(100 millis).timeout(firstTimeoutSelector, timeoutSelector, other).toBlockingObservable.toList
+    println(result)
+  }
+
 }
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index 74794a3c77..7b5b7fe79c 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -1756,6 +1756,102 @@ trait Observable[+T]
     toScalaObservable[U](thisJava.timeout(timeout.length, timeout.unit, otherJava, scheduler.asJavaScheduler))
   }
 
+  /**
+   * Returns an Observable that mirrors the source Observable, but emits a TimeoutException if an item emitted by
+   * the source Observable doesn't arrive within a window of time after the emission of the
+   * previous item, where that period of time is measured by an Observable that is a function
+   * of the previous item.
+   * 
    
+   * 
+   * 
    
+   * Note: The arrival of the first source item is never timed out.
+   *
+   * @param timeoutSelector
+   *            a function that returns an observable for each item emitted by the source
+   *            Observable and that determines the timeout window for the subsequent item
+   * @return an Observable that mirrors the source Observable, but emits a TimeoutException if a item emitted by
+   *         the source Observable takes longer to arrive than the time window defined by the
+   *         selector for the previously emitted item
+   */
+  def timeout[V](timeoutSelector: T => Observable[V]): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.timeout({ t: T => timeoutSelector(t).asJavaObservable.asInstanceOf[rx.Observable[V]] }))
+  }
+
+  /**
+   * Returns an Observable that mirrors the source Observable, but that switches to a fallback
+   * Observable if an item emitted by the source Observable doesn't arrive within a window of time
+   * after the emission of the previous item, where that period of time is measured by an
+   * Observable that is a function of the previous item.
+   * 
    
+   * 
+   * 
    
+   * Note: The arrival of the first source item is never timed out.
+   * 
+   * @param timeoutSelector
+   *            a function that returns an observable for each item emitted by the source
+   *            Observable and that determines the timeout window for the subsequent item
+   * @param other
+   *            the fallback Observable to switch to if the source Observable times out
+   * @return an Observable that mirrors the source Observable, but switches to mirroring a
+   *         fallback Observable if a item emitted by the source Observable takes longer to arrive
+   *         than the time window defined by the selector for the previously emitted item
+   */
+  def timeout[V, O >: T](timeoutSelector: T => Observable[V], other: Observable[O]): Observable[O] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[O]]
+    toScalaObservable[O](thisJava.timeout(
+      { t: O => timeoutSelector(t.asInstanceOf[T]).asJavaObservable.asInstanceOf[rx.Observable[V]] },
+      other.asJavaObservable))
+  }
+
+  /**
+   * Returns an Observable that mirrors the source Observable, but emits a TimeoutException
+   * if either the first item emitted by the source Observable or any subsequent item
+   * don't arrive within time windows defined by other Observables.
+   * 
    
+   * 
+   * 
    
+   * @param firstTimeoutSelector
+   *            a function that returns an Observable that determines the timeout window for the
+   *            first source item
+   * @param timeoutSelector
+   *            a function that returns an Observable for each item emitted by the source
+   *            Observable and that determines the timeout window in which the subsequent source
+   *            item must arrive in order to continue the sequence
+   * @return an Observable that mirrors the source Observable, but emits a TimeoutException if either the first item or any subsequent item doesn't
+   *         arrive within the time windows specified by the timeout selectors
+   */
+  def timeout[U, V](firstTimeoutSelector: () => Observable[U], timeoutSelector: T => Observable[V]): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.timeout(
+      { firstTimeoutSelector().asJavaObservable.asInstanceOf[rx.Observable[U]] },
+      { t: T => timeoutSelector(t).asJavaObservable.asInstanceOf[rx.Observable[V]] }))
+  }
+
+  /**
+   * Returns an Observable that mirrors the source Observable, but switches to a fallback
+   * Observable if either the first item emitted by the source Observable or any subsequent item
+   * don't arrive within time windows defined by other Observables.
+   * 
    
+   * 
+   * 
    
+   * @param firstTimeoutSelector
+   *            a function that returns an Observable which determines the timeout window for the
+   *            first source item
+   * @param timeoutSelector
+   *            a function that returns an Observable for each item emitted by the source
+   *            Observable and that determines the timeout window in which the subsequent source
+   *            item must arrive in order to continue the sequence
+   * @param other
+   *            the fallback Observable to switch to if the source Observable times out
+   * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if either the first item emitted by the source Observable or any
+   *         subsequent item don't arrive within time windows defined by the timeout selectors
+   */
+  def timeout[U, V, O >: T](firstTimeoutSelector: () => Observable[U], timeoutSelector: T => Observable[V], other: Observable[O]): Observable[O] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[O]]
+    toScalaObservable[O](thisJava.timeout(
+      { firstTimeoutSelector().asJavaObservable.asInstanceOf[rx.Observable[U]] },
+      { t: O => timeoutSelector(t.asInstanceOf[T]).asJavaObservable.asInstanceOf[rx.Observable[V]] },
+      other.asJavaObservable))
+  }
 
   /**
    * Returns an Observable that sums up the elements of this Observable.
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index cb5b82fd46..05a28ecf6f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7753,8 +7753,8 @@ public final Observable> timeInterval(Scheduler scheduler) {
      *            a function that returns an Observable for each item emitted by the source
      *            Observable and that determines the timeout window in which the subsequent source
      *            item must arrive in order to continue the sequence
-     * @return an Observable that completes if either the first item or any subsequent item doesn't
-     *         arrive within the time windows specified by the timeout selectors
+     * @return an Observable that mirrors the source Observable, but emits a TimeoutException if 
+     *         either the first item or any subsequent item doesn't arrive within the time windows specified by the timeout selectors
      */
     public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
         return timeout(firstTimeoutSelector, timeoutSelector, null);
@@ -7805,7 +7805,7 @@ public final  Observable timeout(Func0> firstTi
      * @param timeoutSelector
      *            a function that returns an observable for each item emitted by the source
      *            Observable and that determines the timeout window for the subsequent item
-     * @return an Observable that mirrors the source Observable, but completes if a item emitted by
+     * @return an Observable that mirrors the source Observable, but emits a TimeoutException if a item emitted by
      *         the source Observable takes longer to arrive than the time window defined by the
      *         selector for the previously emitted item
      */
@@ -7821,7 +7821,7 @@ public final  Observable timeout(Func1>
      * 
    
      * 
      * 
    
-     * The arrival of the first source item is never timed out.
+     * Note: The arrival of the first source item is never timed out.
      * 
      * @param 
      *            the timeout value type (ignored)

From cbd7c0380846149e6a06a5b5223869aa8ab45da2 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 13 Feb 2014 13:44:35 -0800
Subject: [PATCH 391/441] javadoc changes: add nest() diagram, make some
 0.17-related corrections, fix typos, make formatting consistent & 112-column

---
 rxjava-core/src/main/java/rx/Observable.java | 3932 +++++++++---------
 1 file changed, 1979 insertions(+), 1953 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 05a28ecf6f..3980d48a59 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1,17 +1,14 @@
 /**
  * Copyright 2014 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
+ * 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.
+ * 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;
 
@@ -145,16 +142,14 @@
 /**
  * The Observable class that implements the Reactive Pattern.
  * 
    
- * This class provides methods for subscribing to the Observable as well as delegate methods to the
- * various Observers.
+ * This class provides methods for subscribing to the Observable as well as delegate methods to the various
+ * Observers.
  * 
    
- * The documentation for this class makes use of marble diagrams. The following legend explains
- * these diagrams:
+ * The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
  * 
    
  * 
  * 
    
- * For more information see the
- * RxJava Wiki
+ * For more information see the RxJava Wiki
  * 
  * @param 
  *            the type of the items emitted by the Observable
@@ -166,8 +161,8 @@ public class Observable {
     /**
      * Observable with Function to execute when subscribed to.
      * 
    
-     * Note: Use {@link #create(OnSubscribe)} to create an Observable, instead of this
-     * constructor, unless you specifically have a need for inheritance.
+     * Note: Use {@link #create(OnSubscribe)} to create an Observable, instead of this constructor,
+     * unless you specifically have a need for inheritance.
      * 
      * @param f
      *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
@@ -179,28 +174,28 @@ protected Observable(OnSubscribe f) {
     private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
     /**
-     * Returns an Observable that will execute the specified function when a {@link Subscriber}
-     * subscribes to it.
+     * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
+     * it.
      * 
    
      * 
      * 
    
-     * Write the function you pass to {@code create} so that it behaves as an Observable: It should
-     * invoke the Subscriber's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError},
-     * and {@link Subscriber#onCompleted onCompleted} methods appropriately.
+     * Write the function you pass to {@code create} so that it behaves as an Observable: It should invoke the
+     * Subscriber's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError}, and
+     * {@link Subscriber#onCompleted onCompleted} methods appropriately.
      * 
    
-     * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method
-     * exactly once or its {@code onError} method exactly once.
+     * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method exactly once or
+     * its {@code onError} method exactly once.
      * 
    
-     * See Rx Design Guidelines (PDF)
-     * for detailed information.
+     * See Rx Design Guidelines (PDF) for detailed
+     * information.
      * 
      * @param 
      *            the type of the items that this Observable emits
      * @param f
      *            a function that accepts an {@code Subscriber}, and invokes its {@code onNext},
      *            {@code onError}, and {@code onCompleted} methods as appropriate
-     * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the
-     *         specified function
+     * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
+     *         function
      * @see RxJava Wiki: create()
      * @see MSDN: Observable.Create
      */
@@ -224,7 +219,7 @@ public interface Operator extends Func1, Subscriber<
 
 
     /**
-     * @Deprecated 
+     * @deprecated use {@link #create(OnSubscribe)}
      */
     @Deprecated
     public final static  Observable create(final OnSubscribeFunc f) {
@@ -251,15 +246,18 @@ public static interface OnSubscribeFunc extends Function {
     }
 
     /**
-     * Lift a function to the current Observable and return a new Observable that when subscribed to will pass the values of the current Observable through the function.
+     * Lift a function to the current Observable and return a new Observable that when subscribed to will pass
+     * the values of the current Observable through the function.
      * 
    
-     * In other words, this allows chaining Observers together on an Observable for acting on the values within the Observable.
+     * In other words, this allows chaining Observers together on an Observable for acting on the values within
+     * the Observable.
      * 
     {@code
      * observable.map(...).filter(...).take(5).lift(new ObserverA()).lift(new ObserverB(...)).subscribe()
      * }
      * 
      * @param bind
-     * @return an Observable that emits values that are the result of applying the bind function to the values of the current Observable
+     * @return an Observable that emits values that are the result of applying the bind function to the values
+     *         of the current Observable
      */
     public  Observable lift(final Operator bind) {
         return new Observable(new OnSubscribe() {
@@ -270,9 +268,9 @@ public void call(Subscriber o) {
         });
     }
 
-    /* ******************************************************************************
+    /* *********************************************************************************************************
      * Observers Below Here
-     * ******************************************************************************
+     * *********************************************************************************************************
      */
 
     /**
@@ -282,8 +280,8 @@ public void call(Subscriber o) {
      * 
      * @param sources
      *            an Iterable of Observable sources competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -300,8 +298,8 @@ public final static  Observable amb(IterableRxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -320,8 +318,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o3
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -342,8 +340,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o4
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -366,8 +364,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o5
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -392,8 +390,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o6
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -420,8 +418,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o7
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -450,8 +448,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o8
      *            an observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -482,8 +480,8 @@ public final static  Observable amb(Observable o1, Observable
      *            an Observable competing to react first
      * @param o9
      *            an Observable competing to react first
-     * @return an Observable that emits the same sequence of items as whichever of the source
-     *         Observables first emitted an item
+     * @return an Observable that emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
      * @see RxJava Wiki: amb()
      * @see MSDN: Observable.Amb
      */
@@ -506,8 +504,8 @@ public final static Observable average(Observable source) {
      * 
      * @param source
      *            source Observable to compute the average of
-     * @return an Observable that emits a single item: the average of all the Doubles emitted
-     *         by the source Observable
+     * @return an Observable that emits a single item: the average of all the Doubles emitted by the source
+     *         Observable
      * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
@@ -522,8 +520,8 @@ public final static Observable averageDouble(Observable source)
      * 
      * @param source
      *            source Observable to compute the average of
-     * @return an Observable that emits a single item: the average of all the Floats emitted by
-     *         the source Observable
+     * @return an Observable that emits a single item: the average of all the Floats emitted by the source
+     *         Observable
      * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
@@ -532,15 +530,14 @@ public final static Observable averageFloat(Observable source) {
     }
 
     /**
-     * Returns an Observable that emits the average of the Integers emitted by the source
-     * Observable.
+     * Returns an Observable that emits the average of the Integers emitted by the source Observable.
      * 
    
      * 
      * 
      * @param source
      *            source Observable to compute the average of
-     * @return an Observable that emits a single item: the average of all the Integers emitted
-     *         by the source Observable
+     * @return an Observable that emits a single item: the average of all the Integers emitted by the source
+     *         Observable
      * @throws IllegalArgumentException
      *             if the source Observable emits no items
      * @see RxJava Wiki: averageInteger()
@@ -557,8 +554,8 @@ public final static Observable averageInteger(Observable sourc
      * 
      * @param source
      *            source Observable to compute the average of
-     * @return an Observable that emits a single item: the average of all the Longs emitted by
-     *         the source Observable
+     * @return an Observable that emits a single item: the average of all the Longs emitted by the source
+     *         Observable
      * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
@@ -567,9 +564,9 @@ public final static Observable averageLong(Observable source) {
     }
 
     /**
-     * Combines two source Observables by emitting an item that aggregates the latest values of each
-     * of the source Observables each time an item is received from either of the source
-     * Observables, where this aggregation is defined by a specified function.
+     * Combines two source Observables by emitting an item that aggregates the latest values of each of the
+     * source Observables each time an item is received from either of the source Observables, where this
+     * aggregation is defined by a specified function.
      * 
    
      * 
      * 
@@ -578,10 +575,9 @@ public final static Observable averageLong(Observable source) {
      * @param o2
      *            the second source Observable
      * @param combineFunction
-     *            the aggregation function used to combine the items emitted by the source
-     *            Observables
-     * @return an Observable that emits items that are the result of combining the items emitted by
-     *         the source Observables by means of the given aggregation function
+     *            the aggregation function used to combine the items emitted by the source Observables
+     * @return an Observable that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
      * @see RxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Func2 combineFunction) {
@@ -589,9 +585,9 @@ public final static  Observable combineLatest(Observable
      * 
      * 
@@ -602,10 +598,9 @@ public final static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) {
@@ -613,9 +608,9 @@ public final static  Observable combineLatest(Observable
      * 
      * 
@@ -628,10 +623,9 @@ public final static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4,
@@ -640,9 +634,9 @@ public final static  Observable combineLatest(Observable
      * 
      * 
@@ -657,10 +651,9 @@ public final static  Observable combineLatest(ObservableRxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5,
@@ -669,9 +662,9 @@ public final static  Observable combineLatest(Observab
     }
 
     /**
-     * Combines six source Observables by emitting an item that aggregates the latest values of each
-     * of the source Observables each time an item is received from any of the source Observables,
-     * where this aggregation is defined by a specified function.
+     * Combines six source Observables by emitting an item that aggregates the latest values of each of the
+     * source Observables each time an item is received from any of the source Observables, where this
+     * aggregation is defined by a specified function.
      * 
    
      * 
      * 
@@ -688,10 +681,9 @@ public final static  Observable combineLatest(Observab
      * @param o6
      *            the sixth source Observable
      * @param combineFunction
-     *            the aggregation function used to combine the items emitted by the source
-     *            Observables
-     * @return an Observable that emits items that are the result of combining the items emitted by
-     *         the source Observables by means of the given aggregation function
+     *            the aggregation function used to combine the items emitted by the source Observables
+     * @return an Observable that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
      * @see RxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6,
@@ -700,9 +692,9 @@ public final static  Observable combineLatest(Obse
     }
 
     /**
-     * Combines seven source Observables by emitting an item that aggregates the latest values of
-     * each of the source Observables each time an item is received from any of the source
-     * Observables, where this aggregation is defined by a specified function.
+     * Combines seven source Observables by emitting an item that aggregates the latest values of each of the
+     * source Observables each time an item is received from any of the source Observables, where this
+     * aggregation is defined by a specified function.
      * 
    
      * 
      * 
@@ -721,10 +713,9 @@ public final static  Observable combineLatest(Obse
      * @param o7
      *            the seventh source Observable
      * @param combineFunction
-     *            the aggregation function used to combine the items emitted by the source
-     *            Observables
-     * @return an Observable that emits items that are the result of combining the items emitted by
-     *         the source Observables by means of the given aggregation function
+     *            the aggregation function used to combine the items emitted by the source Observables
+     * @return an Observable that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
      * @see RxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7,
@@ -733,9 +724,9 @@ public final static  Observable combineLatest(
     }
 
     /**
-     * Combines eight source Observables by emitting an item that aggregates the latest values of
-     * each of the source Observables each time an item is received from any of the source
-     * Observables, where this aggregation is defined by a specified function.
+     * Combines eight source Observables by emitting an item that aggregates the latest values of each of the
+     * source Observables each time an item is received from any of the source Observables, where this
+     * aggregation is defined by a specified function.
      * 
    
      * 
      * 
@@ -756,10 +747,9 @@ public final static  Observable combineLatest(
      * @param o8
      *            the eighth source Observable
      * @param combineFunction
-     *            the aggregation function used to combine the items emitted by the source
-     *            Observables
-     * @return an Observable that emits items that are the result of combining the items emitted by
-     *         the source Observables by means of the given aggregation function
+     *            the aggregation function used to combine the items emitted by the source Observables
+     * @return an Observable that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
      * @see RxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
@@ -768,9 +758,9 @@ public final static  Observable combineLat
     }
 
     /**
-     * Combines nine source Observables by emitting an item that aggregates the latest values of
-     * each of the source Observables each time an item is received from any of the source
-     * Observables, where this aggregation is defined by a specified function.
+     * Combines nine source Observables by emitting an item that aggregates the latest values of each of the
+     * source Observables each time an item is received from any of the source Observables, where this
+     * aggregation is defined by a specified function.
      * 
    
      * 
      * 
@@ -793,10 +783,9 @@ public final static  Observable combineLat
      * @param o9
      *            the ninth source Observable
      * @param combineFunction
-     *            the aggregation function used to combine the items emitted by the source
-     *            Observables
-     * @return an Observable that emits items that are the result of combining the items emitted by
-     *         the source Observables by means of the given aggregation function
+     *            the aggregation function used to combine the items emitted by the source Observables
+     * @return an Observable that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
      * @see RxJava Wiki: combineLatest()
      */
     public final static  Observable combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8,
@@ -806,14 +795,15 @@ public final static  Observable combin
     }
 
     /**
-     * Returns an Observable that emits the items emitted by each of the Observables emitted by an
-     * Observable, one after the other, without interleaving them.
+     * Returns an Observable that emits the items emitted by each of the Observables emitted by an Observable,
+     * one after the other, without interleaving them.
      * 
    
      * 
      * 
      * @param observables
      *            an Observable that emits Observables
-     * @return an Observable that emits items all of the items emitted by the Observables emitted by {@code observables}, one after the other, without interleaving them
+     * @return an Observable that emits items all of the items emitted by the Observables emitted by
+     *         {@code observables}, one after the other, without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -822,8 +812,8 @@ public final static  Observable concat(Observable
      * 
      * 
@@ -831,8 +821,8 @@ public final static  Observable concat(ObservableRxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -843,8 +833,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by three Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by three Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -854,8 +844,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t3
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the three source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the three source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -866,8 +856,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by four Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by four Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -879,8 +869,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t4
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the four source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the four source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -891,8 +881,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by five Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by five Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -906,8 +896,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t5
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the five source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the five source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -918,8 +908,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by six Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by six Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -935,8 +925,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t6
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the six source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the six source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -947,8 +937,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by seven Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by seven Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -966,8 +956,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t7
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the seven source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the seven source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -978,8 +968,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by eight Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by eight Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -999,8 +989,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t8
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the eight source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the eight source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -1011,8 +1001,8 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that emits the items emitted by nine Observables, one after the other,
-     * without interleaving them.
+     * Returns an Observable that emits the items emitted by nine Observables, one after the other, without
+     * interleaving them.
      * 
    
      * 
      * 
@@ -1034,8 +1024,8 @@ public final static  Observable concat(Observable t1, Observa
      *            an Observable to be concatenated
      * @param t9
      *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the nine source Observables, one after the
-     *         other, without interleaving them
+     * @return an Observable that emits items emitted by the nine source Observables, one after the other,
+     *         without interleaving them
      * @see RxJava Wiki: concat()
      * @see MSDN: Observable.Concat
      */
@@ -1046,23 +1036,23 @@ public final static  Observable concat(Observable t1, Observa
     }
 
     /**
-     * Returns an Observable that calls an Observable factory to create its Observable for each new
-     * Observer that subscribes. That is, for each subscriber, the actual Observable that subscriber
-     * observes is determined by the factory function.
+     * Returns an Observable that calls an Observable factory to create its Observable for each new Observer
+     * that subscribes. That is, for each subscriber, the actual Observable that subscriber observes is
+     * determined by the factory function.
      * 
    
      * 
      * 
    
-     * The defer Observer 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.
+     * The defer Observer 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
+     *            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' subscriptions trigger an invocation of the
-     *         given Observable factory function
+     * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given
+     *         Observable factory function
      * @see RxJava Wiki: defer()
      */
     public final static  Observable defer(Func0> observableFactory) {
@@ -1070,13 +1060,15 @@ public final static  Observable defer(Func0
      * 
      * 
      * @param 
      *            the type of the items (ostensibly) emitted by the Observable
-     * @return an Observable that emits no items to the {@link Observer} but immediately invokes the {@link Observer}'s {@link Observer#onCompleted() onCompleted} method
+     * @return an Observable that emits no items to the {@link Observer} but immediately invokes the
+     *         {@link Observer}'s {@link Observer#onCompleted() onCompleted} method
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty
      */
@@ -1085,16 +1077,18 @@ public final static  Observable empty() {
     }
 
     /**
-     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method on the specified scheduler.
+     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its
+     * {@link Observer#onCompleted onCompleted} method on the specified Scheduler.
      * 
    
      * 
      * 
      * @param scheduler
-     *            the scheduler to use to call the {@link Observer#onCompleted onCompleted} method
+     *            the Scheduler to use to call the {@link Observer#onCompleted onCompleted} method
      * @param 
      *            the type of the items (ostensibly) emitted by the Observable
-     * @return an Observable that emits no items to the {@link Observer} but immediately invokes the {@link Observer}'s {@link Observer#onCompleted() onCompleted} method with the
-     *         specified {@code scheduler}
+     * @return an Observable that emits no items to the {@link Observer} but immediately invokes the
+     *         {@link Observer}'s {@link Observer#onCompleted() onCompleted} method with the specified
+     *         {@code scheduler}
      * @see RxJava Wiki: empty()
      * @see MSDN: Observable.Empty Method (IScheduler)
      */
@@ -1103,7 +1097,8 @@ public final static  Observable empty(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the Observer subscribes to it.
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
+     * Observer subscribes to it.
      * 
    
      * 
      * 
@@ -1111,7 +1106,8 @@ public final static  Observable empty(Scheduler scheduler) {
      *            the particular Throwable to pass to {@link Observer#onError onError}
      * @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
+     * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method when
+     *         the Observer subscribes to it
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
      */
@@ -1120,17 +1116,19 @@ public final static  Observable error(Throwable exception) {
     }
 
     /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method on the specified scheduler.
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method on the
+     * specified Scheduler.
      * 
    
      * 
      * 
      * @param exception
      *            the particular Throwable to pass to {@link Observer#onError onError}
      * @param scheduler
-     *            the scheduler on which to call {@link Observer#onError onError}
+     *            the Scheduler on which to call {@link Observer#onError onError}
      * @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, on the specified scheduler
+     * @return an Observable that invokes the {@link Observer}'s {@link Observer#onError onError} method, on
+     *         the specified Scheduler
      * @see RxJava Wiki: error()
      * @see MSDN: Observable.Throw
      */
@@ -1143,17 +1141,17 @@ public final static  Observable error(Throwable exception, Scheduler sched
      * 
    
      * 
      * 
    
-     * 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.
+     * 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
+     *            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}
      * @see RxJava Wiki: from()
      */
@@ -1166,9 +1164,9 @@ public final static  Observable from(Future future) {
      * 
    
      * 
      * 
    
-     * 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.
+     * 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.
      * 
@@ -1179,8 +1177,8 @@ public final static  Observable from(Future future) {
      * @param unit
      *            the {@link TimeUnit} of the {@code timeout} argument
      * @param 
-     *            the type of object that the {@link Future} returns, and also the type of item to
-     *            be emitted by the resulting Observable
+     *            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}
      * @see RxJava Wiki: from()
      */
@@ -1193,18 +1191,19 @@ public final static  Observable from(Future future, long time
      * 
    
      * 
      * 
    
-     * 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.
+     * 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.
+     *            the {@link Scheduler} to wait for the Future on. Use a Scheduler such as
+     *            {@link Schedulers#io()} 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
+     *            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}
      * @see RxJava Wiki: from()
      */
@@ -1213,16 +1212,15 @@ public final static  Observable from(Future future, Scheduler
     }
 
     /**
-     * Converts an {@link Iterable} sequence into an Observable that emits the items in the
-     * sequence.
+     * Converts an {@link Iterable} sequence into an Observable that emits the items in the sequence.
      * 
    
      * 
      * 
      * @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
+     *            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
      * @see RxJava Wiki: from()
      */
@@ -1231,20 +1229,20 @@ public final static  Observable from(Iterable iterable) {
     }
 
     /**
-     * Converts an {@link Iterable} sequence into an Observable that operates on the specified
-     * scheduler, emitting each item from the sequence.
+     * Converts an {@link Iterable} sequence into an Observable that operates on the specified Scheduler,
+     * emitting each item from the sequence.
      * 
    
      * 
      * 
      * @param iterable
      *            the source {@link Iterable} sequence
      * @param scheduler
-     *            the scheduler on which the Observable is to emit the items of the iterable
+     *            the Scheduler on which the Observable is to emit the items of the Iterable
      * @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, on the
-     *         specified scheduler
+     *            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, on the specified
+     *         Scheduler
      * @see RxJava Wiki: from()
      * @see MSDN: Observable.ToObservable
      */
@@ -1282,7 +1280,7 @@ public final static  Observable from(T t1) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2))}
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1305,7 +1303,7 @@ public final static  Observable from(T t1, T t2) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1330,7 +1328,7 @@ public final static  Observable from(T t1, T t2, T t3) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1357,7 +1355,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1386,7 +1384,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5,t6))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1417,7 +1415,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5,t6,t7))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1450,7 +1448,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5,t6,t7,t8))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1485,7 +1483,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5,t6,t7,t8,t9))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1523,7 +1521,7 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      *            the type of these items
      * @return an Observable that emits each item
      * @see RxJava Wiki: from()
-     * @deprecated Use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1))}.
+     * @deprecated use {@link #from(Iterable)} instead such as {@code from(Arrays.asList(t1,t2,t3,t4,t5,t6,t7,t8,t9,t10))}.
      */
     @Deprecated
     // suppress unchecked because we are using varargs inside the method
@@ -1537,10 +1535,9 @@ public final static  Observable from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * 
      * 
      * @param items
-     *            the source array
+     *            the source Array
      * @param 
-     *            the type of items in the Array and the type of items to be emitted by the
-     *            resulting Observable
+     *            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
      * @see RxJava Wiki: from()
      */
@@ -1550,18 +1547,16 @@ public final static  Observable from(T... t1) {
     }
 
     /**
-     * Converts an Array into an Observable that emits the items in the Array on a specified
-     * scheduler.
+     * Converts an Array into an Observable that emits the items in the Array on a specified Scheduler.
      * 
    
      * 
      * 
      * @param items
-     *            the source array
+     *            the source Array
      * @param scheduler
-     *            the scheduler on which the Observable emits the items of the array
+     *            the Scheduler on which the Observable emits the items of the Array
      * @param 
-     *            the type of items in the Array and the type of items to be emitted by the
-     *            resulting Observable
+     *            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
      * @see RxJava Wiki: from()
      */
@@ -1588,7 +1583,7 @@ public final static Observable interval(long interval, TimeUnit unit) {
 
     /**
      * Returns an Observable that emits a sequential number every specified interval of time, on a
-     * specified scheduler.
+     * specified Scheduler.
      * 
    
      * 
      * 
@@ -1597,7 +1592,7 @@ public final static Observable interval(long interval, TimeUnit unit) {
      * @param unit
      *            time units to use for the interval size
      * @param scheduler
-     *            the scheduler to use for scheduling the items
+     *            the Scheduler to use for scheduling the items
      * @return an Observable that emits a sequential number each time interval
      * @see RxJava Wiki: interval()
      * @see MSDN: Observable.Interval
@@ -1611,11 +1606,13 @@ public final static Observable interval(long interval, TimeUnit unit, Sche
      * 
    
      * 
      * 
    
-     * To convert any object into an Observable that emits that object, pass that object into the {@code just} method.
+     * To convert any object into an Observable that emits that object, pass that object into the {@code just}
+     * method.
      * 
    
-     * This is similar to the {@link #from(java.lang.Object[])} method, except that {@code 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 {@code just()} method converts an Iterable into an
-     * Observable that emits the entire Iterable as a single item.
+     * This is similar to the {@link #from(java.lang.Object[])} method, except that {@code 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 {@code just()} method converts an Iterable into an Observable that emits the entire
+     * Iterable as a single item.
      * 
      * @param value
      *            the item to emit
@@ -1629,7 +1626,7 @@ public final static  Observable just(T value) {
     }
     
     /**
-     * Returns an Observable that emits a single item and then completes, on a specified scheduler.
+     * Returns an Observable that emits a single item and then completes, on a specified Scheduler.
      * 
    
      * 
      * 
    
@@ -1640,11 +1637,11 @@ public final static  Observable just(T value) {
      * @param 
      *            the type of that item
      * @param scheduler
-     *            the scheduler to emit the single item on
-     * @return an Observable that emits {@code value} as a single item and then completes, on a
-     *         specified scheduler
+     *            the Scheduler to emit the single item on
+     * @return an Observable that emits {@code value} as a single item and then completes, on a specified
+     *         Scheduler
      * @see RxJava Wiki: just()
-     * @deprecated Use {@link #from(T)}
+     * @deprecated use {@link #from(T)}
      */
     @Deprecated
     public final static  Observable just(T value, Scheduler scheduler) {
@@ -1652,9 +1649,9 @@ public final static  Observable just(T value, Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that emits the single item emitted by the source Observable with the
-     * maximum numeric value. If there is more than one item with the same maximum value, it emits
-     * the last-emitted of these.
+     * Returns an Observable that emits the single item emitted by the source Observable with the maximum
+     * numeric value. If there is more than one item with the same maximum value, it emits the last-emitted of
+     * these.
      * 
    
      * 
      * 
@@ -1675,13 +1672,13 @@ public final static > Observable max(Observab
      * 
    
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
      *            the Iterable of Observables
-     * @return an Observable that emits items that are the result of flattening the items emitted by
-     *         the Observables in the Iterable
+     * @return an Observable that emits items that are the result of flattening the items emitted by the
+     *         Observables in the Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1690,21 +1687,22 @@ public final static  Observable merge(Iterable
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
      *            the Iterable of Observables
      * @param maxConcurrent
      *            the maximum number of Observables that may be subscribed to concurrently
-     * @return an Observable that emits items that are the result of flattening the items emitted by
-     *         the Observables in the Iterable
-     * @throw IllegalArgumentException if {@code maxConcurrent} is less than or equal to 0
+     * @return an Observable that emits items that are the result of flattening the items emitted by the
+     *         Observables in the Iterable
+     * @throw IllegalArgumentException
+     *            if {@code maxConcurrent} is less than or equal to 0
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1713,24 +1711,25 @@ public final static  Observable merge(Iterable
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
      *            the Iterable of Observables
      * @param maxConcurrent
      *            the maximum number of Observables that may be subscribed to concurrently
      * @param scheduler
-     *            the scheduler on which to traverse the Iterable of Observables
-     * @return an Observable that emits items that are the result of flattening the items emitted by
-     *         the Observables in the Iterable
-     * @throw IllegalArgumentException if {@code maxConcurrent} is less than or equal to 0
+     *            the Scheduler on which to traverse the Iterable of Observables
+     * @return an Observable that emits items that are the result of flattening the items emitted by the
+     *         Observables in the Iterable
+     * @throw IllegalArgumentException
+     *            if {@code maxConcurrent} is less than or equal to 0
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1739,20 +1738,20 @@ public final static  Observable merge(Iterable
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
      *            the Iterable of Observables
      * @param scheduler
-     *            the scheduler on which to traverse the Iterable of Observables
-     * @return an Observable that emits items that are the result of flattening the items emitted by
-     *         the Observables in the Iterable
+     *            the Scheduler on which to traverse the Iterable of Observables
+     * @return an Observable that emits items that are the result of flattening the items emitted by the
+     *         Observables in the Iterable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1761,18 +1760,18 @@ public final static  Observable merge(Iterable
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as 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 Observables
-     *         emitted by the {@code source} Observable
+     * @return an Observable that emits items that are the result of flattening the Observables emitted by the
+     *         {@code source} Observable
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1781,22 +1780,23 @@ public final static  Observable merge(Observable
      * 
      * 
    
-     * You can combine the items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param source
      *            an Observable that emits Observables
      * @param maxConcurrent
      *            the maximum number of Observables that may be subscribed to concurrently
-     * @return an Observable that emits items that are the result of flattening the Observables
-     *         emitted by the {@code source} Observable
-     * @throw IllegalArgumentException if {@code maxConcurrent} is less than or equal to 0
+     * @return an Observable that emits items that are the result of flattening the Observables emitted by the
+     *         {@code source} Observable
+     * @throw IllegalArgumentException
+     *            if {@code maxConcurrent} is less than or equal to 0
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -1809,8 +1809,8 @@ public final static  Observable merge(Observable
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1829,8 +1829,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1851,8 +1851,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1875,8 +1875,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1901,8 +1901,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1929,8 +1929,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1959,8 +1959,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -1992,8 +1992,8 @@ public final static  Observable merge(Observable t1, Observab
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2023,16 +2023,16 @@ public final static  Observable merge(Observable t1, Observab
     }
 
     /**
-     * Flattens an array of Observables into one Observable, without any transformation.
+     * Flattens an Array of Observables into one Observable, without any transformation.
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
-     *            the array of Observables
-     * @return an Observable that emits all of the items emitted by the Observables in the array
+     *            the Array of Observables
+     * @return an Observable that emits all of the items emitted by the Observables in the Array
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -2041,19 +2041,19 @@ public final static  Observable merge(Observable[] sequences)
     }
 
     /**
-     * Flattens an array of Observables into one Observable, without any transformation, traversing
-     * the array on a specified scheduler.
+     * Flattens an Array of Observables into one Observable, without any transformation, traversing the array on
+     * a specified Scheduler.
      * 
    
      * 
      * 
    
-     * You can combine items emitted by multiple Observables so that they appear as a single
-     * Observable, by using the {@code merge} method.
+     * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
+     * using the {@code merge} method.
      * 
      * @param sequences
-     *            the array of Observables
+     *            the Array of Observables
      * @param scheduler
-     *            the scheduler on which to traverse the array
-     * @return an Observable that emits all of the items emitted by the Observables in the array
+     *            the Scheduler on which to traverse the Array
+     * @return an Observable that emits all of the items emitted by the Observables in the Array
      * @see RxJava Wiki: merge()
      * @see MSDN: Observable.Merge
      */
@@ -2062,21 +2062,22 @@ public final static  Observable merge(Observable[] sequences,
     }
 
     /**
-     * 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * 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 observe all successfully emitted items from all of the
-     * source Observables without being interrupted by an error notification from one of them.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param source
      *            an Observable that emits Observables
-     * @return an Observable that emits all of the items emitted by the Observables emitted by the {@code source} Observable
+     * @return an Observable that emits all of the items emitted by the Observables emitted by the
+     *         {@code source} Observable
      * @see RxJava Wiki: mergeDelayError()
      * @see MSDN: Observable.Merge
      */
@@ -2085,23 +2086,23 @@ public final static  Observable mergeDelayError(Observable
-     * 
+     * This behaves like {@link #merge(Observable, 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 both 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 each of the
-     * source Observables without being interrupted by an error notification from one of them.
+     * Even if both merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
      * @param t2
      *            an Observable to be merged
-     * @return an Observable that emits all of the items that are emitted by the two source
-     *         Observables
+     * @return an Observable that emits all of the items that are emitted by the two source Observables
      * @see RxJava Wiki: mergeDelayError()
      * @see MSDN: Observable.Merge
      */
@@ -2112,16 +2113,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2140,16 +2143,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2170,16 +2175,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2202,16 +2209,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2236,16 +2245,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2272,16 +2283,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2310,16 +2323,18 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * A version of merge that 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.
      * 
    
-     * 
+     * This behaves like {@link #merge(Observable, Observable, Observable, Observable, Observable, Observable, Observable, Observable, 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.
+     * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
+     * invoke the {@code onError} method of its Observers once.
      * 
      * @param t1
      *            an Observable to be merged
@@ -2350,8 +2365,8 @@ public final static  Observable mergeDelayError(Observable t1
     }
 
     /**
-     * Returns an Observable that emits the single numerically minimum item emitted by the source
-     * Observable. If there is more than one such item, it returns the last-emitted one.
+     * Returns an Observable that emits the single numerically minimum item emitted by the source Observable.
+     * If there is more than one such item, it returns the last-emitted one.
      * 
    
      * 
      * 
@@ -2368,8 +2383,10 @@ public final static > Observable min(Observab
 
     /**
      * Convert the current Observable into an Observable>.
+     * 
    
+     * 
      * 
-     * @return
+     * @return an Observable that emits a single item: the source Observable
      */
     public final Observable> nest() {
         return from(this);
@@ -2392,16 +2409,18 @@ public final static  Observable never() {
     }
 
     /**
-     * Converts an {@code Observable>} into another {@code Observable>} whose emitted Observables emit the same items, but the number of such Observables is
-     * restricted by {@code parallelObservables}.
+     * Converts an {@code Observable>} into another {@code Observable>} whose
+     * emitted Observables emit the same items, but the number of such Observables is restricted by
+     * {@code parallelObservables}.
      * 
    
-     * For example, if the original {@code Observable>} emits 100 Observables and {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be
-     * distributed among 8 Observables emitted by the resulting Observable.
+     * For example, if the original {@code Observable>} emits 100 Observables and
+     * {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be distributed
+     * among 8 Observables emitted by the resulting Observable.
      * 
    
      * 
      * 
    
-     * This is a mechanism for efficiently processing n number of Observables on a smaller
-     * m number of resources (typically CPU cores).
+     * This is a mechanism for efficiently processing n number of Observables on a smaller m
+     * number of resources (typically CPU cores).
      * 
      * @param parallelObservables
      *            the number of Observables to merge into
@@ -2413,16 +2432,18 @@ public final static  Observable> parallelMerge(Observable>} into another {@code Observable>} whose emitted Observables emit the same items, but the number of such Observables is
-     * restricted by {@code parallelObservables}, and each runs on a defined Scheduler.
+     * Converts an {@code Observable>} into another {@code Observable>} whose
+     * emitted Observables emit the same items, but the number of such Observables is restricted by
+     * {@code parallelObservables}, and each runs on a defined Scheduler.
      * 
    
-     * For example, if the original {@code Observable>} emits 100 Observables and {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be
-     * distributed among 8 Observables emitted by the resulting Observable.
+     * For example, if the original {@code Observable>} emits 100 Observables and
+     * {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be distributed
+     * among 8 Observables emitted by the resulting Observable.
      * 
    
      * 
      * 
    
-     * This is a mechanism for efficiently processing n number of Observables on a smaller
-     * m number of resources (typically CPU cores).
+     * This is a mechanism for efficiently processing n number of Observables on a smaller m
+     * number of resources (typically CPU cores).
      * 
      * @param parallelObservables
      *            the number of Observables to merge into
@@ -2459,8 +2480,8 @@ public final static Observable range(int start, int count) {
     }
 
     /**
-     * Returns an Observable that emits a sequence of Integers within a specified range, on a
-     * specified scheduler.
+     * Returns an Observable that emits a sequence of Integers within a specified range, on a specified
+     * Scheduler.
      * 
    
      * 
      * 
@@ -2469,7 +2490,7 @@ public final static Observable range(int start, int count) {
      * @param count
      *            the number of sequential Integers to generate
      * @param scheduler
-     *            the scheduler to run the generator loop on
+     *            the Scheduler to run the generator loop on
      * @return an Observable that emits a range of sequential Integers
      * @see RxJava Wiki: range()
      * @see MSDN: Observable.Range
@@ -2479,8 +2500,8 @@ public final static Observable range(int start, int count, Scheduler sc
     }
 
     /**
-     * Returns an Observable that emits a Boolean value that indicates whether two Observable
-     * sequences are the same by comparing the items emitted by each Observable pairwise.
+     * Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the
+     * same by comparing the items emitted by each Observable pairwise.
      * 
    
      * 
      * 
@@ -2490,8 +2511,7 @@ public final static Observable range(int start, int count, Scheduler sc
      *            the second Observable to compare
      * @param 
      *            the type of items emitted by each Observable
-     * @return an Observable that emits a Boolean value that indicates whether the two sequences are
-     *         the same
+     * @return an Observable that emits a Boolean value that indicates whether the two sequences are the same
      * @see RxJava Wiki: sequenceEqual()
      */
     public final static  Observable sequenceEqual(Observable first, Observable second) {
@@ -2507,9 +2527,9 @@ public final Boolean call(T first, T second) {
     }
 
     /**
-     * Returns an Observable that emits a Boolean value that indicates whether two Observable
-     * sequences are the same by comparing the items emitted by each Observable pairwise based on
-     * the results of a specified equality function.
+     * Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the
+     * same by comparing the items emitted by each Observable pairwise based on the results of a specified
+     * equality function.
      * 
    
      * 
      * 
@@ -2521,8 +2541,8 @@ public final Boolean call(T first, T second) {
      *            a function used to compare items emitted by each Observable
      * @param 
      *            the type of items emitted by each Observable
-     * @return an Observable that emits a Boolean value that indicates whether the two Observable
-     *         two sequences are the same according to the specified function
+     * @return an Observable that emits a Boolean value that indicates whether the two Observable two sequences
+     *         are the same according to the specified function
      * @see RxJava Wiki: sequenceEqual()
      */
     public final static  Observable sequenceEqual(Observable first, Observable second, Func2 equality) {
@@ -2536,8 +2556,8 @@ public final static  Observable sequenceEqual(ObservableRxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
@@ -2552,8 +2572,8 @@ public final static Observable sumDouble(Observable source) {
      * 
      * @param source
      *            the source Observable to compute the sum of
-     * @return an Observable that emits a single item: the sum of all the Floats emitted by the
-     *         source Observable
+     * @return an Observable that emits a single item: the sum of all the Floats emitted by the source
+     *         Observable
      * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
@@ -2562,15 +2582,14 @@ public final static Observable sumFloat(Observable source) {
     }
 
     /**
-     * Returns an Observable that emits the sum of all the Integers emitted by the source
-     * Observable.
+     * Returns an Observable that emits the sum of all the Integers emitted by the source Observable.
      * 
    
      * 
      * 
      * @param source
      *            source Observable to compute the sum of
-     * @return an Observable that emits a single item: the sum of all the Integers emitted by the
-     *         source Observable
+     * @return an Observable that emits a single item: the sum of all the Integers emitted by the source
+     *         Observable
      * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
@@ -2595,21 +2614,20 @@ public final static Observable sumLong(Observable source) {
     }
 
     /**
-     * Given an Observable that emits Observables, returns an Observable that emits the items
-     * emitted by the most recently emitted of those Observables.
+     * Given an Observable that emits Observables, returns an Observable that emits the items emitted by the
+     * most recently emitted of those Observables.
      * 
    
      * 
      * 
    
-     * {@code switchDo()} subscribes to an Observable that emits Observables. Each time it
-     * observes one of these emitted Observables, the Observable returned by {@code switchDo()}
-     * begins emitting the items emitted by that Observable. When a new Observable is emitted,
-     * {@code switchDo()} stops emitting items from the earlier-emitted Observable and begins
-     * emitting items from the new one.
+     * {@code switchDo()} subscribes to an Observable that emits Observables. Each time it observes one of these
+     * emitted Observables, the Observable returned by {@code switchDo()} begins emitting the items emitted by
+     * that Observable. When a new Observable is emitted, {@code switchDo()} stops emitting items from the
+     * earlier-emitted Observable and begins emitting items from the new one.
      * 
      * @param sequenceOfSequences
      *            the source Observable that emits Observables
-     * @return an Observable that emits the items emitted by the Observable most recently emitted by
-     *         the source Observable
+     * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
+     *         Observable
      * @see RxJava Wiki: switchOnNext()
      * @deprecated use {@link #switchOnNext}
      */
@@ -2619,21 +2637,20 @@ public final static  Observable switchDo(Observable
      * 
      * 
    
-     * {@code switchLatest()} subscribes to an Observable that emits Observables. Each time it
-     * observes one of these emitted Observables, the Observable returned by {@code switchLatest()}
-     * begins emitting the items emitted by that Observable. When a new Observable is emitted,
-     * {@code switchLatest()} stops emitting items from the earlier-emitted Observable and begins
-     * emitting items from the new one.
+     * {@code switchLatest()} subscribes to an Observable that emits Observables. Each time it observes one of
+     * these emitted Observables, the Observable returned by {@code switchLatest()} begins emitting the items
+     * emitted by that Observable. When a new Observable is emitted, {@code switchLatest()} stops emitting items
+     * from the earlier-emitted Observable and begins emitting items from the new one.
      * 
      * @param sequenceOfSequences
      *            the source Observable that emits Observables
-     * @return an Observable that emits the items emitted by the Observable most recently emitted by
-     *         the source Observable
+     * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
+     *         Observable
      * @see RxJava Wiki: switchOnNext()
      * @see {@link #switchOnNext(Observable)}
      */
@@ -2642,21 +2659,20 @@ public final static  Observable switchLatest(Observable
      * 
      * 
    
-     * {@code switchOnNext()} subscribes to an Observable that emits Observables. Each time it
-     * observes one of these emitted Observables, the Observable returned by {@code switchOnNext()}
-     * begins emitting the items emitted by that Observable. When a new Observable is emitted,
-     * {@code switchOnNext()} stops emitting items from the earlier-emitted Observable and begins
-     * emitting items from the new one.
+     * {@code switchOnNext()} subscribes to an Observable that emits Observables. Each time it observes one of
+     * these emitted Observables, the Observable returned by {@code switchOnNext()} begins emitting the items
+     * emitted by that Observable. When a new Observable is emitted, {@code switchOnNext()} stops emitting items
+     * from the earlier-emitted Observable and begins emitting items from the new one.
      * 
      * @param sequenceOfSequences
      *            the source Observable that emits Observables
-     * @return an Observable that emits the items emitted by the Observable most recently emitted by
-     *         the source Observable
+     * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
+     *         Observable
      * @see RxJava Wiki: switchOnNext()
      */
     public final static  Observable switchOnNext(Observable> sequenceOfSequences) {
@@ -2672,8 +2688,8 @@ public final static  Observable synchronize(Observable source) {
     }
 
     /**
-     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
-     * numbers after each {@code period} of time thereafter.
+     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
+     * each {@code period} of time thereafter.
      * 
    
      * 
      * 
@@ -2683,8 +2699,8 @@ public final static  Observable synchronize(Observable source) {
      *            the period of time between emissions of the subsequent numbers
      * @param unit
      *            the time unit for both {@code initialDelay} and {@code period}
-     * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
-     *         numbers after each {@code period} of time thereafter
+     * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
+     *         each {@code period} of time thereafter
      * @see RxJava Wiki: timer()
      * @see MSDN: Observable.Timer
      */
@@ -2693,8 +2709,8 @@ public final static Observable timer(long initialDelay, long period, TimeU
     }
 
     /**
-     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
-     * numbers after each {@code period} of time thereafter, on a specified Scheduler.
+     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
+     * each {@code period} of time thereafter, on a specified Scheduler.
      * 
    
      * 
      * 
@@ -2705,9 +2721,9 @@ public final static Observable timer(long initialDelay, long period, TimeU
      * @param unit
      *            the time unit for both {@code initialDelay} and {@code period}
      * @param scheduler
-     *            the scheduler on which the waiting happens and items are emitted
-     * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing
-     *         numbers after each {@code period} of time thereafter, while running on the given {@code scheduler}
+     *            the Scheduler on which the waiting happens and items are emitted
+     * @return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
+     *         each {@code period} of time thereafter, while running on the given Scheduler
      * @see RxJava Wiki: timer()
      * @see MSDN: Observable.Timer
      */
@@ -2723,7 +2739,7 @@ public final static Observable timer(long initialDelay, long period, TimeU
      * @param delay
      *            the initial delay before emitting a single 0L
      * @param unit
-     *            time units to use for the delay
+     *            time units to use for {@code delay}
      * @see RxJava wiki: timer()
      */
     public final static Observable timer(long delay, TimeUnit unit) {
@@ -2731,17 +2747,17 @@ public final static Observable timer(long delay, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits one item after a specified delay, on a specified scheduler,
-     * and then completes.
+     * Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then
+     * completes.
      * 
    
      * 
      * 
      * @param delay
      *            the initial delay before emitting a single 0L
      * @param unit
-     *            time units to use for the delay
+     *            time units to use for {@code delay}
      * @param scheduler
-     *            the scheduler to use for scheduling the item
+     *            the Scheduler to use for scheduling the item
      * @see RxJava wiki: timer()
      */
     public final static Observable timer(long delay, TimeUnit unit, Scheduler scheduler) {
@@ -3019,24 +3035,24 @@ public final static  Observable when(Plan0 p1, Plan0 p2, Plan0 p3
     }
 
     /**
-     * Returns an Observable that emits the results of a function of your choosing applied to
-     * combinations items emitted, in sequence, by an Iterable of 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 each of
-     * the source Observables; 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.
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * items emitted, in sequence, by an Iterable of 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 each of the source Observables;
+     * 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.
+     * 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 Iterable 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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3049,27 +3065,24 @@ public final static  Observable zip(Iterable> ws,
     }
 
     /**
-     * Returns an Observable that emits the results of a function of your choosing applied to
-     * combinations of n items emitted, in sequence, by the n Observables emitted by
-     * a specified Observable.
-     * 
     {@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 each of
-     * the Observables emitted by the source Observable; 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.
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * n items emitted, in sequence, by the n Observables emitted by a specified Observable.
      * 
    
-     * 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.
+     * {@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 each of the Observables emitted
+     * by the source Observable; 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 Observables
-     *            emitted by {@code ws}, results in an item that will be emitted by the resulting
-     *            Observable
+     *            a function that, when applied to an item emitted by each of the Observables emitted by
+     *            {@code ws}, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      * @see RxJava Wiki: zip()
      */
@@ -3085,25 +3098,27 @@ public Observable[] call(List> o) {
     }
 
     /**
-     * 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.
+     * 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 o1} and the first item emitted by {@code o2}; the second item emitted by the new Observable will
-     * be the result of the function applied to the second item emitted by {@code o1} and the second
-     * item emitted by {@code o2}; 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.
+     * {@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 o1} and the first item
+     * emitted by {@code o2}; the second item emitted by the new Observable will be the result of the function
+     * applied to the second item emitted by {@code o1} and the second item emitted by {@code o2}; 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
      *            the first source Observable
      * @param o2
      *            a second 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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3112,18 +3127,20 @@ public final static  Observable zip(Observable o1, O
     }
 
     /**
-     * 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.
+     * 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 o1}, the first item emitted by {@code o2}, and the first item emitted by {@code o3};
-     * the second item emitted by the new Observable will be the result of the function applied to
-     * the second item emitted by {@code o1}, the second item emitted by {@code o2}, and the second
-     * item emitted by {@code o3}; 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.
+     * {@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 o1}, the first item
+     * emitted by {@code o2}, and the first item emitted by {@code o3}; the second item emitted by the new
+     * Observable will be the result of the function applied to the second item emitted by {@code o1}, the
+     * second item emitted by {@code o2}, and the second item emitted by {@code o3}; 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
      *            the first source Observable
@@ -3132,8 +3149,8 @@ public final static  Observable zip(Observable o1, O
      * @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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3142,18 +3159,20 @@ public final static  Observable zip(Observable o
     }
 
     /**
-     * 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.
+     * 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 o1}, the first item emitted by {@code o2}, the first item emitted by {@code o3}, and
-     * the first item emitted by {@code 04}; 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.
+     * {@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 o1}, the first item
+     * emitted by {@code o2}, the first item emitted by {@code o3}, and the first item emitted by {@code 04};
+     * 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
      *            the first source Observable
@@ -3164,8 +3183,8 @@ public final static  Observable zip(Observable o
      * @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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3174,18 +3193,20 @@ public final static  Observable zip(Observable
      * 
-     * 
     {@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 o1}, the first item emitted by {@code o2}, the first item emitted by {@code o3}, the
-     * first item emitted by {@code o4}, and the first item emitted by {@code o5}; 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.
+     * {@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 o1}, the first item
+     * emitted by {@code o2}, the first item emitted by {@code o3}, the first item emitted by {@code o4}, and
+     * the first item emitted by {@code o5}; 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
      *            the first source Observable
@@ -3198,8 +3219,8 @@ public final static  Observable zip(ObservableRxJava Wiki: zip()
      */
@@ -3208,17 +3229,19 @@ public final static  Observable zip(Observable
      * 
-     * 
     {@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 each source
-     * Observable, 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.
+     * {@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 each source Observable, 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
      *            the first source Observable
@@ -3233,8 +3256,8 @@ public final static  Observable zip(ObservableRxJava Wiki: zip()
      */
@@ -3244,17 +3267,19 @@ public final static  Observable zip(Observable
      * 
-     * 
     {@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 each source
-     * Observable, 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.
+     * {@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 each source Observable, 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
      *            the first source Observable
@@ -3271,8 +3296,8 @@ public final static  Observable zip(ObservableRxJava Wiki: zip()
      */
@@ -3282,17 +3307,19 @@ public final static  Observable zip(Observable
     }
 
     /**
-     * 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.
+     * 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 each source
-     * Observable, 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.
+     * {@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 each source Observable, 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
      *            the first source Observable
@@ -3311,8 +3338,8 @@ public final static  Observable zip(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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3322,17 +3349,19 @@ public final static  Observable zip(Observ
     }
 
     /**
-     * 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.
+     * 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 each source
-     * Observable, 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.
+     * {@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 each source Observable, 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
      *            the first source Observable
@@ -3353,8 +3382,8 @@ public final static  Observable zip(Observ
      * @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
+     *            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
      * @see RxJava Wiki: zip()
      */
@@ -3392,15 +3421,15 @@ public final  Observable aggregate(R initialValue, Func2
     }
 
     /**
-     * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by
-     * the source Observable satisfy a condition.
+     * 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 {@code true} if all items emitted by the source Observable
-     *         satisfy the predicate; otherwise, {@code false}
+     * @return an Observable that emits {@code true} if all items emitted by the source Observable satisfy the
+     *         predicate; otherwise, {@code false}
      * @see RxJava Wiki: all()
      */
     public final Observable all(Func1 predicate) {
@@ -3425,9 +3454,9 @@ public final  Pattern2 and(Observable right) {
     }
 
     /**
-     * Hides the identity of this Observable. Useful for instance when you have an implementation
-     * of a subclass of Observable but you want to hide the properties and methods of this subclass
-     * from whomever you are passing the Observable to.
+     * Hides the identity of this Observable. Useful for instance when you have an implementation of a subclass
+     * of Observable but you want to hide the properties and methods of this subclass from whomever you are
+     * passing the Observable to.
      * 
      * @return an Observable that hides the identity of this Observable
      */
@@ -3436,17 +3465,15 @@ public final Observable asObservable() {
     }
 
     /**
-     * Returns an Observable that transforms items emitted by the source Observable into Doubles by
-     * using a function you provide and then emits the Double average of the complete sequence of
-     * transformed values.
+     * Returns an Observable that transforms items emitted by the source Observable into Doubles by using a
+     * function you provide and then emits the Double average of the complete sequence of transformed values.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to transform an item emitted by the source Observable into a Double
-     * @return an Observable that emits a single item: the Double average of the complete sequence
-     *         of items emitted by the source Observable when transformed into Doubles by the
-     *         specified function
+     * @return an Observable that emits a single item: the Double average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Doubles by the specified function
      * @see RxJava Wiki: averageDouble()
      * @see MSDN: Observable.Average
      */
@@ -3455,17 +3482,15 @@ public final Observable averageDouble(Func1 valueExtr
     }
 
     /**
-     * Returns an Observable that transforms items emitted by the source Observable into Floats by
-     * using a function you provide and then emits the Float average of the complete sequence of
-     * transformed values.
+     * Returns an Observable that transforms items emitted by the source Observable into Floats by using a
+     * function you provide and then emits the Float average of the complete sequence of transformed values.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to transform an item emitted by the source Observable into a Float
-     * @return an Observable that emits a single item: the Float average of the complete sequence of
-     *         items emitted by the source Observable when transformed into Floats by the specified
-     *         function
+     * @return an Observable that emits a single item: the Float average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Floats by the specified function
      * @see RxJava Wiki: averageFloat()
      * @see MSDN: Observable.Average
      */
@@ -3474,17 +3499,15 @@ public final Observable averageFloat(Func1 valueExtract
     }
 
     /**
-     * Returns an Observable that transforms items emitted by the source Observable into Integers by
-     * using a function you provide and then emits the Integer average of the complete sequence of
-     * transformed values.
+     * Returns an Observable that transforms items emitted by the source Observable into Integers by using a
+     * function you provide and then emits the Integer average of the complete sequence of transformed values.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to transform an item emitted by the source Observable into an Integer
-     * @return an Observable that emits a single item: the Integer average of the complete sequence
-     *         of items emitted by the source Observable when transformed into Integers by the
-     *         specified function
+     * @return an Observable that emits a single item: the Integer average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Integers by the specified function
      * @see RxJava Wiki: averageInteger()
      * @see MSDN: Observable.Average
      */
@@ -3493,17 +3516,15 @@ public final Observable averageInteger(Func1 valueE
     }
 
     /**
-     * Returns an Observable that transforms items emitted by the source Observable into Longs by
-     * using a function you provide and then emits the Long average of the complete sequence of
-     * transformed values.
+     * Returns an Observable that transforms items emitted by the source Observable into Longs by using a
+     * function you provide and then emits the Long average of the complete sequence of transformed values.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to transform an item emitted by the source Observable into a Long
-     * @return an Observable that emits a single item: the Long average of the complete sequence of
-     *         items emitted by the source Observable when transformed into Longs by the specified
-     *         function
+     * @return an Observable that emits a single item: the Long average of the complete sequence of items
+     *         emitted by the source Observable when transformed into Longs by the specified function
      * @see RxJava Wiki: averageLong()
      * @see MSDN: Observable.Average
      */
@@ -3512,19 +3533,21 @@ public final Observable averageLong(Func1 valueExtractor)
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping buffers. It emits the current
-     * buffer and replaces it with a new buffer when the Observable produced by the specified {@code bufferClosingSelector} emits an item. It then uses the {@code bufferClosingSelector} to create a
-     * new Observable to observe to indicate the end of the next buffer.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a
+     * new buffer when the Observable produced by the specified {@code bufferClosingSelector} emits an item. It
+     * then uses the {@code bufferClosingSelector} to create a new Observable to observe to indicate the end of
+     * the next buffer.
      * 
    
      * 
      * 
      * @param bufferClosingSelector
-     *            a {@link Func0} that produces an Observable for each buffer created. When
-     *            this {@code Observable} emits an item, {@code buffer()} emits the associated
-     *            buffer and replaces it with a new one.
-     * @return an Observable that emits a connected, non-overlapping buffer of items from
-     *         the source Observable each time the current Observable created with the {@code bufferClosingSelector} argument emits an item
+     *            a {@link Func0} that produces an Observable for each buffer created. When this
+     *            {@code Observable} emits an item, {@code buffer()} emits the associated buffer and replaces it
+     *            with a new one
+     * @return an Observable that emits a connected, non-overlapping buffer of items from the source Observable
+     *         each time the current Observable created with the {@code bufferClosingSelector} argument emits an
+     *         item
      * @see RxJava Wiki: buffer()
      */
     public final  Observable> buffer(Func0> bufferClosingSelector) {
@@ -3532,17 +3555,17 @@ public final  Observable> buffer(Func0
      * 
      * 
      * @param count
      *            the maximum number of items in each buffer before it should be emitted
-     * @return an Observable that emits connected, non-overlapping buffers, each containing
-     *         at most {@code count} items from the source Observable
+     * @return an Observable that emits connected, non-overlapping buffers, each containing at most
+     *         {@code count} items from the source Observable
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(int count) {
@@ -3550,21 +3573,21 @@ public final Observable> buffer(int count) {
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits buffers every {@code skip} items, each containing {@code count} items. When the source Observable completes or encounters an error, the
-     * resulting Observable emits the current buffer and propagates the notification from the source
-     * Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits buffers every {@code skip} items, each containing {@code count} items. When the source
+     * Observable completes or encounters an error, the resulting Observable emits the current buffer and
+     * propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param count
      *            the maximum size of each buffer before it should be emitted
      * @param skip
-     *            how many items emitted by the source Observable should be skipped before starting
-     *            a new buffer. Note that when {@code skip} and {@code count} are equal, this is the
-     *            same operation as {@link #buffer(int)}.
-     * @return an Observable that emits buffers for every {@code skip} item from the source
-     *         Observable and containing at most {@code count} items
+     *            how many items emitted by the source Observable should be skipped before starting a new
+     *            buffer. Note that when {@code skip} and {@code count} are equal, this is the same operation as
+     *            {@link #buffer(int)}.
+     * @return an Observable that emits buffers for every {@code skip} item from the source Observable and
+     *         containing at most {@code count} items
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(int count, int skip) {
@@ -3572,11 +3595,11 @@ public final Observable> buffer(int count, int skip) {
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable starts a new buffer periodically, as determined by the {@code timeshift} argument. It emits each buffer after a fixed timespan, specified by the {@code timespan}
-     * argument. When the source Observable completes or encounters an error, the
-     * resulting Observable emits the current buffer and propagates the notification from the source
-     * Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable starts a new buffer periodically, as determined by the {@code timeshift} argument. It emits
+     * each buffer after a fixed timespan, specified by the {@code timespan} argument. When the source
+     * Observable completes or encounters an error, the resulting Observable emits the current buffer and
+     * propagates the notification from the source Observable.
      * 
    
      * 
      * 
@@ -3586,8 +3609,8 @@ public final Observable> buffer(int count, int skip) {
      *            the period of time after which a new buffer will be created
      * @param unit
      *            the unit of time that applies to the {@code timespan} and {@code timeshift} arguments
-     * @return an Observable that emits new buffers of items emitted by the source
-     *         Observable periodically after a fixed timespan has elapsed
+     * @return an Observable that emits new buffers of items emitted by the source Observable periodically after
+     *         a fixed timespan has elapsed
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, long timeshift, TimeUnit unit) {
@@ -3595,11 +3618,11 @@ public final Observable> buffer(long timespan, long timeshift, TimeUnit
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable starts a new buffer periodically, as determined by the {@code timeshift} argument, and on the specified {@code scheduler}. It emits each buffer
-     * after a fixed timespan, specified by the {@code timespan} argument. When the source
-     * Observable completes or encounters an error, the resulting Observable emits the current
-     * buffer propagates the notification from the source Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable starts a new buffer periodically, as determined by the {@code timeshift} argument, and on the
+     * specified {@code scheduler}. It emits each buffer after a fixed timespan, specified by the
+     * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting
+     * Observable emits the current buffer and propagates the notification from the source Observable.
      * 
    
      * 
      * 
@@ -3611,8 +3634,8 @@ public final Observable> buffer(long timespan, long timeshift, TimeUnit
      *            the unit of time that applies to the {@code timespan} and {@code timeshift} arguments
      * @param scheduler
      *            the {@link Scheduler} to use when determining the end and start of a buffer
-     * @return an Observable that emits new buffers of items emitted by the source
-     *         Observable periodically after a fixed timespan has elapsed
+     * @return an Observable that emits new buffers of items emitted by the source Observable periodically after
+     *         a fixed timespan has elapsed
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
@@ -3620,21 +3643,20 @@ public final Observable> buffer(long timespan, long timeshift, TimeUnit
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration
-     * specified by the {@code timespan} argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current buffer and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the
+     * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting
+     * Observable emits the current buffer and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each buffer collects items before it is emitted and replaced
-     *            with a new buffer
+     *            the period of time each buffer collects items before it is emitted and replaced with a new
+     *            buffer
      * @param unit
      *            the unit of time that applies to the {@code timespan} argument
-     * @return an Observable that emits connected, non-overlapping buffers of items emitted
-     *         by the source Observable within a fixed duration
+     * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source
+     *         Observable within a fixed duration
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, TimeUnit unit) {
@@ -3642,24 +3664,24 @@ public final Observable> buffer(long timespan, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration
-     * specified by the {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached first). When the source Observable completes or encounters an
-     * error, the resulting Observable emits the current buffer and propagates the notification from
-     * the source Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the
+     * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached
+     * first). When the source Observable completes or encounters an error, the resulting Observable emits the
+     * current buffer and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each buffer collects items before it is emitted and replaced
-     *            with a new buffer
+     *            the period of time each buffer collects items before it is emitted and replaced with a new
+     *            buffer
      * @param unit
      *            the unit of time which applies to the {@code timespan} argument
      * @param count
      *            the maximum size of each buffer before it is emitted
-     * @return an Observable that emits connected, non-overlapping buffers of items emitted
-     *         by the source Observable, after a fixed duration or when the buffer reaches maximum
-     *         capacity (whichever occurs first)
+     * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source
+     *         Observable, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs
+     *         first)
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, TimeUnit unit, int count) {
@@ -3667,27 +3689,27 @@ public final Observable> buffer(long timespan, TimeUnit unit, int count)
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration
-     * specified by the {@code timespan} argument as measured on the specified {@code scheduler}, or
-     * a maximum size specified by the {@code count} argument (whichever is reached first). When the
-     * source Observable completes or encounters an error, the resulting Observable emits the
-     * current buffer and propagates the notification from the source Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the
+     * {@code timespan} argument as measured on the specified {@code scheduler}, or a maximum size specified by
+     * the {@code count} argument (whichever is reached first). When the source Observable completes or
+     * encounters an error, the resulting Observable emits the current buffer and propagates the notification
+     * from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each buffer collects items before it is emitted and replaced
-     *            with a new buffer
+     *            the period of time each buffer collects items before it is emitted and replaced with a new
+     *            buffer
      * @param unit
      *            the unit of time which applies to the {@code timespan} argument
      * @param count
      *            the maximum size of each buffer before it is emitted
      * @param scheduler
      *            the {@link Scheduler} to use when determining the end and start of a buffer
-     * @return an Observable that emits connected, non-overlapping buffers of items emitted
-     *         by the source Observable after a fixed duration or when the buffer reaches maximum
-     *         capacity (whichever occurs first)
+     * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source
+     *         Observable after a fixed duration or when the buffer reaches maximum capacity (whichever occurs
+     *         first)
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
@@ -3695,23 +3717,23 @@ public final Observable> buffer(long timespan, TimeUnit unit, int count,
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration
-     * specified by the {@code timespan} argument and on the specified {@code scheduler}. When the
-     * source Observable completes or encounters an error, the resulting Observable emits the
-     * current buffer and propagates the notification from the source Observable.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the
+     * {@code timespan} argument and on the specified {@code scheduler}. When the source Observable completes or
+     * encounters an error, the resulting Observable emits the current buffer and propagates the notification
+     * from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each buffer collects items before it is emitted and replaced
-     *            with a new buffer
+     *            the period of time each buffer collects items before it is emitted and replaced with a new
+     *            buffer
      * @param unit
      *            the unit of time which applies to the {@code timespan} argument
      * @param scheduler
      *            the {@link Scheduler} to use when determining the end and start of a buffer
-     * @return an Observable that emits connected, non-overlapping buffers of items emitted
-     *         by the source Observable within a fixed duration
+     * @return an Observable that emits connected, non-overlapping buffers of items emitted by the source
+     *         Observable within a fixed duration
      * @see RxJava Wiki: buffer()
      */
     public final Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
@@ -3719,22 +3741,19 @@ public final Observable> buffer(long timespan, TimeUnit unit, Scheduler
     }
 
     /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable.
-     * The resulting Observable emits buffers that it creates when the specified {@code bufferOpenings} Observable emits an item, and closes when the Observable returned from
-     * {@code bufferClosingSelector} emits an item.
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits buffers that it creates when the specified {@code bufferOpenings} Observable emits an
+     * item, and closes when the Observable returned from {@code bufferClosingSelector} emits an item.
      * 
    
      * 
      * 
      * @param bufferOpenings
-     *            the Observable that, when it emits an item, causes a new buffer to be
-     *            created
+     *            the Observable that, when it emits an item, causes a new buffer to be created
      * @param bufferClosingSelector
-     *            the {@link Func1} that is used to produce an Observable for every buffer
-     *            created. When this Observable emits an item, the associated buffer is
-     *            emitted.
-     * @return an Observable that emits buffers, containing items from the source
-     *         Observable, that are created and closed when the specified Observables emit
-     *         items
+     *            the {@link Func1} that is used to produce an Observable for every buffer created. When this
+     *            Observable emits an item, the associated buffer is emitted.
+     * @return an Observable that emits buffers, containing items from the source Observable, that are created
+     *         and closed when the specified Observables emit items
      * @see RxJava Wiki: buffer()
      */
     public final  Observable> buffer(Observable bufferOpenings, Func1> bufferClosingSelector) {
@@ -3742,20 +3761,20 @@ public final  Observable> buffer(Observable
      * 
      * 
    
-     * Completion of either the source or the boundary Observable causes the returned Observable
-     * to emit the latest buffer and complete.
+     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+     * latest buffer and complete.
      * 
      * @param 
      *            the boundary value type (ignored)
      * @param boundary
      *            the boundary Observable
-     * @return an Observable that emits buffered items from the source Observable when the boundary
-     *         Observable emits an item
+     * @return an Observable that emits buffered items from the source Observable when the boundary Observable
+     *         emits an item
      * @see #buffer(rx.Observable, int)
      * @see RxJava Wiki: buffer()
      */
@@ -3764,13 +3783,13 @@ public final  Observable> buffer(Observable boundary) {
     }
 
     /**
-     * Returns an Observable that emits non-overlapping buffered items from the source Observable
-     * each time the specified boundary Observable emits an item.
+     * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
+     * specified boundary Observable emits an item.
      * 
    
      * 
      * 
    
-     * Completion of either the source or the boundary Observable causes the returned Observable
-     * to emit the latest buffer and complete.
+     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+     * latest buffer and complete.
      * 
      * @param 
      *            the boundary value type (ignored)
@@ -3778,8 +3797,8 @@ public final  Observable> buffer(Observable boundary) {
      *            the boundary Observable
      * @param initialCapacity
      *            the initial capacity of each buffer chunk
-     * @return an Observable that emits buffered items from the source Observable when the boundary
-     *         Observable emits an item
+     * @return an Observable that emits buffered items from the source Observable when the boundary Observable
+     *         emits an item
      * @see RxJava Wiki: buffer()
      * @see #buffer(rx.Observable, int)
      */
@@ -3788,25 +3807,26 @@ public final  Observable> buffer(Observable boundary, int initialC
     }
 
     /**
-     * This method has similar behavior to {@link #replay} except that this auto-subscribes to the
-     * source Observable rather than returning a {@link ConnectableObservable}.
+     * 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 Subscriber}s.
      * 
    
-     * When you call {@code cache()}, it does not yet subscribe to the source Observable. This only
-     * happens when {@code subscribe} is called the first time on the Observable returned by
-     * {@code cache()}.
+     * When you call {@code cache()}, it does not yet subscribe to the source Observable. This only happens when
+     * {@code subscribe} is called the first time on the Observable returned by {@code cache()}.
      * 
    
-     *                             
-     * Note: You sacrifice the ability to unsubscribe from the origin when you use the
-     * {@code cache()} Observer so be careful not to use this Observer on Observables that emit an
-     * infinite or very large number of items that will use up memory.
+     *
+     *                           
+     *
+     * Note: You sacrifice the ability to unsubscribe from the origin when you use the {@code cache()}
+     * Observer so be careful not to use this Observer 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 items and
-     *         notifications for the benefit of subsequent observers
+     * @return an Observable that, when first subscribed to, caches all of its items and notifications for the
+     *         benefit of subsequent observers
      * @see RxJava Wiki: cache()
      */
     public final Observable cache() {
@@ -3814,16 +3834,16 @@ public final Observable cache() {
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source Observable, converted to the
-     * specified type.
+     * Returns an Observable that emits the items emitted by the source Observable, converted to the specified
+     * type.
      * 
    
      * 
      * 
      * @param klass
-     *            the target class type that the items emitted by the source Observable will be
-     *            converted to before being emitted by the resulting Observable
-     * @return an Observable that emits each item from the source Observable after converting it to
-     *         the specified type
+     *            the target class type that the items emitted by the source Observable will be converted to
+     *            before being emitted by the resulting Observable
+     * @return an Observable that emits each item from the source Observable after converting it to the
+     *         specified type
      * @see RxJava Wiki: cast()
      * @see MSDN: Observable.Cast
      */
@@ -3834,8 +3854,7 @@ public final  Observable cast(final Class klass) {
     /**
      * Collect values into a single mutable data structure.
      * 
    
-     * This is a simplified version of {@code reduce} that does not need to return the state on each
-     * pass.
+     * This is a simplified version of {@code reduce} that does not need to return the state on each pass.
      * 
    
      * 
      * @param state
@@ -3858,34 +3877,32 @@ public final R call(R state, T value) {
     }
 
     /**
-     * Returns a new Observable that emits items resulting from applying a function that you supply
-     * to each item emitted by the source Observable, where that function returns an Observable, and
-     * then emitting the items that result from concatinating those resulting Observables.
+     * Returns a new Observable that emits items resulting from applying a function that you supply to each item
+     * emitted by the source Observable, where that function returns an Observable, and then emitting the items
+     * that result from concatinating those resulting Observables.
      * 
    
      * 
      * 
      * @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 concatinating the Observables obtained from
-     *         this transformation
+     *            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 concatinating the Observables obtained from this transformation
      */
     public final  Observable concatMap(Func1> func) {
         return concat(map(func));
     }
 
     /**
-     * Returns an Observable that emits a Boolean that indicates whether the source Observable
-     * emitted a specified item.
+     * Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a
+     * specified item.
      * 
    
      * 
      * 
      * @param element
      *            the item to search for in the emissions from the source Observable
-     * @return an Observable that emits {@code true} if the specified item is emitted by the source
-     *         Observable, or {@code false} if the source Observable completes without emitting that
-     *         item
+     * @return an Observable that emits {@code true} if the specified item is emitted by the source Observable,
+     *         or {@code false} if the source Observable completes without emitting that item
      * @see RxJava Wiki: contains()
      * @see MSDN: Observable.Contains
      */
@@ -3898,13 +3915,11 @@ public final Boolean call(T t1) {
     }
 
     /**
-     * Returns an Observable emits the count of the total number of items emitted by the source
-     * Observable.
+     * Returns an Observable that emits the count of the total number of items emitted by the source Observable.
      * 
    
      * 
      * 
-     * @return an Observable that emits a single item: the number of elements emitted by the
-     *         source Observable
+     * @return an Observable that emits a single item: the number of elements emitted by the source Observable
      * @see RxJava Wiki: count()
      * @see MSDN: Observable.Count
      * @see #longCount()
@@ -3919,9 +3934,8 @@ public final Integer call(Integer t1, T t2) {
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, except that it drops items emitted
-     * by the source Observable that are followed by another item within a computed debounce
-     * duration.
+     * Return an Observable that mirrors the source Observable, except that it drops items emitted by the source
+     * Observable that are followed by another item within a computed debounce duration.
      * 
    
      * 
      * 
@@ -3929,20 +3943,20 @@ public final Integer call(Integer t1, T t2) {
      *            the debounce value type (ignored)
      * @param debounceSelector
      *            function to retrieve a sequence that indicates the throttle duration for each item
-     * @return an Observable that omits items emitted by the source Observable that are followed by
-     *         another item within a computed debounce duration
+     * @return an Observable that omits items emitted by the source Observable that are followed by another item
+     *         within a computed debounce duration
      */
     public final  Observable debounce(Func1> debounceSelector) {
         return create(OperationDebounce.debounceSelector(this, debounceSelector));
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, except that it drops items emitted
-     * by the source Observable that are followed by newer items before a timeout value expires.
-     * The timer resets on each emission.
+     * Return an Observable that mirrors the source Observable, except that it drops items emitted by the source
+     * Observable that are followed by newer items before a timeout value expires. The timer resets on each
+     * emission.
      * 
    
-     * Note: If items keep being emitted by the source Observable faster than the timeout
-     * then no items will be emitted by the resulting Observable.
+     * Note: If items keep being emitted by the source Observable faster than the timeout then no items
+     * will be emitted by the resulting Observable.
      * 
    
      * 
      * 
    
@@ -3955,12 +3969,12 @@ public final  Observable debounce(Func1
      * 
      * 
      * @param timeout
-     *            the time each item has to be "the most recent" of those emitted by the source
-     *            Observable to ensure that it's not dropped
+     *            the time each item has to be "the most recent" of those emitted by the source Observable to
+     *            ensure that it's not dropped
      * @param unit
      *            the {@link TimeUnit} for the timeout
-     * @return an Observable that filters out items from the source Observable that are too
-     *         quickly followed by newer items
+     * @return an Observable that filters out items from the source Observable that are too quickly followed by
+     *         newer items
      * @see RxJava Wiki: debounce()
      * @see #throttleWithTimeout(long, TimeUnit)
      */
@@ -3969,12 +3983,12 @@ public final Observable debounce(long timeout, TimeUnit unit) {
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, except that it drops items emitted
-     * by the source Observable that are followed by newer items before a timeout value expires on
-     * a specified Scheduler. The timer resets on each emission.
+     * Return an Observable that mirrors the source Observable, except that it drops items emitted by the source
+     * Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The
+     * timer resets on each emission.
      * 
    
-     * Note: If items keep being emitted by the source Observable faster than the timeout
-     * then no items will be emitted by the resulting Observable.
+     * Note: If items keep being emitted by the source Observable faster than the timeout then no items
+     * will be emitted by the resulting Observable.
      * 
    
      * 
      * 
    
@@ -3987,15 +4001,15 @@ public final Observable debounce(long timeout, TimeUnit unit) {
      * 
      * 
      * @param timeout
-     *            the time each item has to be "the most recent" of those emitted by the source
-     *            Observable to ensure that it's not dropped
+     *            the time each item has to be "the most recent" of those emitted by the source Observable to
+     *            ensure that it's not dropped
      * @param unit
      *            the unit of time for the specified timeout
      * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the timers that handle the
-     *            timeout for each item
-     * @return an Observable that filters out items from the source Observable that are too
-     *         quickly followed by newer items
+     *            the {@link Scheduler} to use internally to manage the timers that handle the timeout for each
+     *            item
+     * @return an Observable that filters out items from the source Observable that are too quickly followed by
+     *         newer items
      * @see RxJava Wiki: debounce()
      * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
      */
@@ -4004,15 +4018,15 @@ public final Observable debounce(long timeout, TimeUnit unit, Scheduler sched
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source Observable or a specified
-     * default item if the source Observable is empty.
+     * Returns an Observable that emits the items emitted by the source Observable or a specified default item
+     * if the source Observable is empty.
      * 
    
      * 
      * 
      * @param defaultValue
      *            the item to emit if the source Observable emits no items
-     * @return an Observable that emits either the specified default item if the source Observable
-     *         emits no items, or the items emitted by the source Observable
+     * @return an Observable that emits either the specified default item if the source Observable emits no
+     *         items, or the items emitted by the source Observable
      * @see RxJava Wiki: defaultIfEmpty()
      * @see MSDN: Observable.DefaultIfEmpty
      */
@@ -4021,26 +4035,27 @@ public final Observable defaultIfEmpty(T defaultValue) {
     }
 
     /**
-     * Returns an Observable that delays the subscription to and emissions from the souce Observable
-     * via another Observable on a per-item basis.
+     * Returns an Observable that delays the subscription to and emissions from the souce Observable via another
+     * Observable on a per-item basis.
      * 
    
      * 
      * 
    
-     * Note: the resulting Observable will immediately propagate any {@code onError} notification from the source Observable.
+     * Note: the resulting Observable will immediately propagate any {@code onError} notification
+     * from the source Observable.
      * 
      * @param 
      *            the subscription delay value type (ignored)
      * @param 
      *            the item delay value type (ignored)
      * @param subscriptionDelay
-     *            a function that returns an Observable that triggers the subscription to the source
-     *            Observable once it emits any item
+     *            a function that returns an Observable that triggers the subscription to the source Observable
+     *            once it emits any item
      * @param itemDelay
-     *            a function that returns an Observable for each item emitted by the source
-     *            Observable, which is then used to delay the emission of that item by the resulting
-     *            Observable until the Observable returned from {@code itemDelay} emits an item
-     * @return an Observable that delays the subscription and emissions of the source Observable via
-     *         another Observable on a per-item basis
+     *            a function that returns an Observable for each item emitted by the source Observable, which is
+     *            then used to delay the emission of that item by the resulting Observable until the Observable
+     *            returned from {@code itemDelay} emits an item
+     * @return an Observable that delays the subscription and emissions of the source Observable via another
+     *         Observable on a per-item basis
      */
     public final  Observable delay(
             Func0> subscriptionDelay,
@@ -4049,29 +4064,30 @@ public final  Observable delay(
     }
 
     /**
-     * Returns an Observable that delays the emissions of the source Observable via another
-     * Observable on a per-item basis.
+     * Returns an Observable that delays the emissions of the source Observable via another Observable on a
+     * per-item basis.
      * 
    
      * 
      * 
    
-     * Note: the resulting Observable will immediately propagate any {@code onError} notification from the source Observable.
+     * Note: the resulting Observable will immediately propagate any {@code onError} notification
+     * from the source Observable.
      * 
      * @param 
      *            the item delay value type (ignored)
      * @param itemDelay
-     *            a function that returns an Observable for each item emitted by the source
-     *            Observable, which is then used to delay the emission of that item by the resulting
-     *            Observable until the Observable returned from {@code itemDelay} emits an item
-     * @return an Observable that delays the emissions of the source Observable via another
-     *         Observable on a per-item basis
+     *            a function that returns an Observable for each item emitted by the source Observable, which is
+     *            then used to delay the emission of that item by the resulting Observable until the Observable
+     *            returned from {@code itemDelay} emits an item
+     * @return an Observable that delays the emissions of the source Observable via another Observable on a
+     *         per-item basis
      */
     public final  Observable delay(Func1> itemDelay) {
         return create(OperationDelay.delay(this, itemDelay));
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source Observable shifted forward
-     * in time by a specified delay. Error notifications from the source Observable are not delayed.
+     * Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a
+     * specified delay. Error notifications from the source Observable are not delayed.
      * 
    
      * 
      * 
@@ -4088,15 +4104,15 @@ public final Observable delay(long delay, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source Observable shifted forward
-     * in time by a specified delay. Error notifications from the source Observable are not delayed.
+     * Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a
+     * specified delay. Error notifications from the source Observable are not delayed.
      * 
    
      * 
      * 
      * @param delay
      *            the delay to shift the source by
      * @param unit
-     *            the {@link TimeUnit} in which {@code period} is defined
+     *            the time unit of {@code delay}
      * @param scheduler
      *            the {@link Scheduler} to use for delaying
      * @return the source Observable shifted in time by the specified delay
@@ -4108,25 +4124,23 @@ public final Observable delay(long delay, TimeUnit unit, Scheduler scheduler)
     }
 
     /**
-     * Return an Observable that delays the subscription to the source Observable by a given amount
-     * of time.
+     * Return an Observable that delays the subscription to the source Observable by a given amount of time.
      * 
    
      * 
      * 
      * @param delay
      *            the time to delay the subscription
      * @param unit
-     *            the time unit
-     * @return an Observable that delays the subscription to the source Observable by the given
-     *         amount
+     *            the time unit of {@code delay}
+     * @return an Observable that delays the subscription to the source Observable by the given amount
      */
     public final Observable delaySubscription(long delay, TimeUnit unit) {
         return delaySubscription(delay, unit, Schedulers.computation());
     }
 
     /**
-     * Return an Observable that delays the subscription to the source Observable by a given amount
-     * of time, both waiting and subscribing on a given Scheduler.
+     * Return an Observable that delays the subscription to the source Observable by a given amount of time,
+     * both waiting and subscribing on a given Scheduler.
      * 
    
      * 
      * 
@@ -4135,7 +4149,7 @@ public final Observable delaySubscription(long delay, TimeUnit unit) {
      * @param unit
      *            the time unit of {@code delay}
      * @param scheduler
-     *            the scheduler on which the waiting and subscription will happen
+     *            the Scheduler on which the waiting and subscription will happen
      * @return an Observable that delays the subscription to the source Observable by a given
      *         amount, waiting and subscribing on the given Scheduler
      */
@@ -4144,13 +4158,14 @@ public final Observable delaySubscription(long delay, TimeUnit unit, Schedule
     }
 
     /**
-     * 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.
+     * 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
+     * @return an Observable that emits the items and notifications embedded in the {@link Notification} objects
+     *         emitted by the source Observable
      * @throws Throwable
      *             if the source Observable is not of type {@code Observable>}
      * @see RxJava Wiki: dematerialize()
@@ -4162,13 +4177,12 @@ public final  Observable dematerialize() {
     }
 
     /**
-     * Returns an Observable that emits all items emitted by the source Observable that are
-     * distinct.
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct.
      * 
    
      * 
      * 
-     * @return an Observable that emits only those items emitted by the source Observable that are
-     *         distinct from each other
+     * @return an Observable that emits only those items emitted by the source Observable that are distinct from
+     *         each other
      * @see RxJava Wiki: distinct()
      * @see MSDN: Observable.distinct
      */
@@ -4177,16 +4191,15 @@ public final Observable distinct() {
     }
 
     /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct
-     * according to a key selector function.
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct according
+     * to a key selector function.
      * 
    
      * 
      * 
      * @param keySelector
-     *            a function that projects an emitted item to a key value that is used to decide
-     *            whether an item is distinct from another one or not
-     * @return an Observable that emits those items emitted by the source Observable that have
-     *         distinct keys
+     *            a function that projects an emitted item to a key value that is used to decide whether an item
+     *            is distinct from another one or not
+     * @return an Observable that emits those items emitted by the source Observable that have distinct keys
      * @see RxJava Wiki: distinct()
      * @see MSDN: Observable.distinct
      */
@@ -4195,13 +4208,13 @@ public final  Observable distinct(Func1 keySelecto
     }
 
     /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct
-     * from their immediate predecessors.
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct from their
+     * immediate predecessors.
      * 
    
      * 
      * 
-     * @return an Observable that emits those items from the source Observable that are distinct
-     *         from their immediate predecessors
+     * @return an Observable that emits those items from the source Observable that are distinct from their
+     *         immediate predecessors
      * @see RxJava Wiki: distinctUntilChanged()
      * @see MSDN: Observable.distinctUntilChanged
      */
@@ -4210,16 +4223,16 @@ public final Observable distinctUntilChanged() {
     }
 
     /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct
-     * from their immediate predecessors, according to a key selector function.
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct from their
+     * immediate predecessors, according to a key selector function.
      * 
    
      * 
      * 
      * @param keySelector
-     *            a function that projects an emitted item to a key value that is used to decide
-     *            whether an item is distinct from another one or not
-     * @return an Observable that emits those items from the source Observable whose keys are
-     *         distinct from those of their immediate predecessors
+     *            a function that projects an emitted item to a key value that is used to decide whether an item
+     *            is distinct from another one or not
+     * @return an Observable that emits those items from the source Observable whose keys are distinct from
+     *         those of their immediate predecessors
      * @see RxJava Wiki: distinctUntilChanged()
      * @see MSDN: Observable.distinctUntilChanged
      */
@@ -4369,18 +4382,18 @@ public final void onNext(T args) {
     }
 
     /**
-     * Returns an Observable that emits the single item at a specified index in a sequence of
-     * emissions from a source Observbable.
+     * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
+     * source Observbable.
      * 
    
      * 
      * 
      * @param index
      *            the zero-based index of the item to retrieve
-     * @return an Observable that emits a single item: the item at the specified position in the
-     *         sequence of those emitted by the source Observable
+     * @return an Observable that emits a single item: the item at the specified position in the sequence of
+     *         those emitted by the source Observable
      * @throws IndexOutOfBoundsException
-     *             if {@code index} is greater than or equal to the number of items emitted by the
-     *             source Observable
+     *             if {@code index} is greater than or equal to the number of items emitted by the source
+     *             Observable
      * @throws IndexOutOfBoundsException
      *             if {@code index} is less than 0
      * @see RxJava Wiki: elementAt()
@@ -4390,8 +4403,8 @@ public final Observable elementAt(int index) {
     }
 
     /**
-     * Returns an Observable that emits the item found at a specified index in a sequence of
-     * emissions from a source Observable, or a default item if that index is out of range.
+     * Returns an Observable that emits the item found at a specified index in a sequence of emissions from a
+     * source Observable, or a default item if that index is out of range.
      * 
    
      * 
      * 
@@ -4399,9 +4412,8 @@ public final Observable elementAt(int index) {
      *            the zero-based index of the item to retrieve
      * @param defaultValue
      *            the default item
-     * @return an Observable that emits the item at the specified position in the sequence emitted
-     *         by the source Observable, or the default item if that index is outside the bounds of
-     *         the source sequence
+     * @return an Observable that emits the item at the specified position in the sequence emitted by the source
+     *         Observable, or the default item if that index is outside the bounds of the source sequence
      * @throws IndexOutOfBoundsException
      *             if {@code index} is less than 0
      * @see RxJava Wiki: elementAtOrDefault()
@@ -4411,20 +4423,21 @@ public final Observable elementAtOrDefault(int index, T defaultValue) {
     }
 
     /**
-     * Returns an Observable that emits {@code true} if any item emitted by the source Observable
-     * satisfies a specified condition, otherwise {@code false}. Note: this always emits {@code false} if the source Observable is empty.
+     * Returns an Observable that emits {@code true} if any item emitted by the source Observable satisfies a
+     * specified condition, otherwise {@code false}. Note: this always emits {@code false} if the
+     * source Observable is empty.
      * 
    
      * 
      * 
    
-     * In Rx.Net this is the {@code any} Observer but we renamed it in RxJava to better match Java
-     * naming idioms.
+     * In Rx.Net this is the {@code any} Observer but we renamed it in RxJava to better match Java naming
+     * idioms.
      * 
      * @param predicate
      *            the condition to test items emitted by the source Observable
-     * @return an Observable that emits a Boolean that indicates whether any item emitted by the
-     *         source Observable satisfies the {@code predicate}
+     * @return an Observable that emits a Boolean that indicates whether any item emitted by the source
+     *         Observable satisfies the {@code predicate}
      * @see RxJava Wiki: exists()
-     * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
+     * @see MSDN: Observable.Any Note: the description in this page was wrong at the time of this writing.
      */
     public final Observable exists(Func1 predicate) {
         return create(OperationAny.exists(this, predicate));
@@ -4436,9 +4449,10 @@ public final Observable exists(Func1 predicate) {
      * 
      * 
      * @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 emitted by the source Observable that the
-     *         filter evaluates as {@code true}
+     *            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 emitted by the source Observable that the filter
+     *         evaluates as {@code true}
      * @see RxJava Wiki: filter()
      */
     public final Observable filter(Func1 predicate) {
@@ -4446,13 +4460,15 @@ public final Observable filter(Func1 predicate) {
     }
 
     /**
-     * Registers an {@link Action0} to be called when this Observable invokes either {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}.
+     * Registers an {@link Action0} to be called when this Observable invokes either
+     * {@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}
+     * @return an Observable that emits the same items as the source Observable, then invokes the
+     *         {@link Action0}
      * @see RxJava Wiki: finallyDo()
      * @see MSDN: Observable.Finally
      */
@@ -4461,13 +4477,13 @@ public final Observable finallyDo(Action0 action) {
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable,
-     * or raises an {@code IllegalArgumentException} if the source Observable is empty.
+     * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an
+     * {@code IllegalArgumentException} if the source Observable is empty.
      * 
    
      * 
      * 
-     * @return an Observable that emits only the very first item emitted by the source Observable,
-     *         or raises an {@code IllegalArgumentException} if the source Observable is empty
+     * @return an Observable that emits only the very first item emitted by the source Observable, or raises an
+     *         {@code IllegalArgumentException} if the source Observable is empty
      * @see RxJava Wiki: first()
      * @see MSDN: {@code Observable.firstAsync()}
      */
@@ -4476,16 +4492,15 @@ public final Observable first() {
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable
-     * that satisfies a specified condition, or raises an {@code IllegalArgumentException} if no
-     * such items are emitted.
+     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
+     * a specified condition, or raises an {@code IllegalArgumentException} if no such items are emitted.
      * 
    
      * 
      * 
      * @param predicate
      *            the condition that an item emitted by the source Observable has to satisfy
-     * @return an Observable that emits only the very first item emitted by the source Observable
-     *         that satisfies the {@code predicate}, or raises an {@code IllegalArgumentException} if no such items are emitted
+     * @return an Observable that emits only the very first item emitted by the source Observable that satisfies
+     *         the {@code predicate}, or raises an {@code IllegalArgumentException} if no such items are emitted
      * @see RxJava Wiki: first()
      * @see MSDN: {@code Observable.firstAsync()}
      */
@@ -4494,15 +4509,15 @@ public final Observable first(Func1 predicate) {
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable,
-     * or a default item if the source Observable completes without emitting anything.
+     * Returns an Observable that emits only the very first item emitted by the source Observable, or a default
+     * item if the source Observable completes without emitting anything.
      * 
    
      * 
      * 
      * @param defaultValue
      *            the default item 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 item
-     *         if the source Observable completes without emitting any items
+     * @return an Observable that emits only the very first item from the source, or a default item if the
+     *         source Observable completes without emitting any items
      * @see RxJava Wiki: firstOrDefault()
      * @see MSDN: {@code Observable.firstOrDefaultAsync()}
      */
@@ -4511,20 +4526,18 @@ public final Observable firstOrDefault(T defaultValue) {
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable
-     * that satisfies a specified condition, or a default item if the source Observable emits no
-     * such items.
+     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
+     * a specified condition, or a default item if the source Observable emits no such items.
      * 
    
      * 
      * 
      * @param predicate
      *            the condition any item emitted by the source Observable has to satisfy
      * @param defaultValue
-     *            the default item to emit if the source Observable doesn't emit anything that
-     *            satisfies the {@code predicate}
-     * @return an Observable that emits only the very first item emitted by the source Observable
-     *         that satisfies the {@code predicate}, or a default item if the source Observable
-     *         emits no such items
+     *            the default item to emit if the source Observable doesn't emit anything that satisfies the
+     *            {@code predicate}
+     * @return an Observable that emits only the very first item emitted by the source Observable that satisfies
+     *         the {@code predicate}, or a default item if the source Observable emits no such items
      * @see RxJava Wiki: firstOrDefault()
      * @see MSDN: {@code Observable.firstOrDefaultAsync()}
      */
@@ -4533,30 +4546,27 @@ public final Observable firstOrDefault(T defaultValue, Func1
      * 
-     * 
    
-     * 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
+     *            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 RxJava Wiki: flatMap()
-     * @see #mapMany(Func1)
      */
     public final  Observable flatMap(Func1> func) {
         return mergeMap(func);
     }
 
     /**
-     * Groups the items emitted by an Observable according to a specified criterion, and emits these
-     * grouped items as {@link GroupedObservable}s, one {@code GroupedObservable} per group.
+     * Groups the items emitted by an Observable according to a specified criterion, and emits these grouped
+     * items as {@link GroupedObservable}s, one {@code GroupedObservable} per group.
      * 
    
      * 
      * 
@@ -4564,9 +4574,8 @@ public final  Observable flatMap(Func1
      *            the key type
-     * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a
-     *         unique key value and each of which emits those items from the source Observable that
-     *         share that key value
+     * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a unique key
+     *         value and each of which emits those items from the source Observable that share that key value
      * @see RxJava Wiki: groupBy
      */
     public final  Observable> groupBy(final Func1 keySelector) {
@@ -4574,8 +4583,9 @@ public final  Observable> groupBy(final Func1
      * 
      * 
@@ -4587,9 +4597,9 @@ public final  Observable> groupBy(final Func1
      *            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 transformed items corresponding to items from the source
-     *         Observable that share that key value
+     * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a unique key
+     *         value and emits transformed items corresponding to items from the source Observable that share
+     *         that key value
      * @see RxJava Wiki: groupBy
      */
     public final  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
@@ -4597,8 +4607,8 @@ public final  Observable> groupBy(final Func1
      * 
      * 
@@ -4606,9 +4616,9 @@ public final  Observable> groupBy(final Func1RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
@@ -4617,21 +4627,21 @@ public final  Observable> groupByUnt
     }
 
     /**
-     * Groups the items emitted by an Observable (transformed by a selector) according to a
-     * specified key selector function until the duration Observable expires for the key.
+     * Groups the items emitted by an Observable (transformed by a selector) according to a specified key
+     * selector function until the duration Observable expires for the key.
      * 
    
      * 
      * 
      * @param keySelector
      *            a function to extract the key for each item
      * @param valueSelector
-     *            a function to map each item emitted by the source Observable to an item emitted by
-     *            one of the resulting {@link GroupedObservable}s
+     *            a function to map each item emitted by the source Observable to an item emitted by one of the
+     *            resulting {@link GroupedObservable}s
      * @param durationSelector
      *            a function to signal the expiration of a group
-     * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a
-     *         key value and each of which emits all items emitted by the source Observable during
-     *         that key's duration that share that same key value, transformed by the value selector
+     * @return an Observable that emits {@link GroupedObservable}s, each of which corresponds to a key value and
+     *         each of which emits all items emitted by the source Observable during that key's duration that
+     *         share that same key value, transformed by the value selector
      * @see RxJava Wiki: groupByUntil()
      * @see MSDN: Observable.GroupByUntil
      */
@@ -4640,24 +4650,23 @@ public final  Observable
      * 
      * 
      * @param right
      *            the other Observable to correlate items from the source Observable with
      * @param leftDuration
-     *            a function that returns an Observable whose emissions indicate the duration of the
-     *            values of the source Observable
+     *            a function that returns an Observable whose emissions indicate the duration of the values of
+     *            the source Observable
      * @param rightDuration
-     *            a function that returns an Observable whose emissions indicate the duration of the
-     *            values of the {@code right} Observable
+     *            a function that returns an Observable whose emissions indicate the duration of the values of
+     *            the {@code right} Observable
      * @param resultSelector
-     *            a function that takes an item emitted by each Observable and returns the value to
-     *            be emitted by the resulting Observable
-     * @return an Observable that emits items based on combining those items emitted by the source
-     *         Observables whose durations overlap
+     *            a function that takes an item emitted by each Observable and returns the value to be emitted
+     *            by the resulting Observable
+     * @return an Observable that emits items based on combining those items emitted by the source Observables
+     *         whose durations overlap
      * @see RxJava Wiiki: groupJoin
      * @see MSDN: Observable.GroupJoin
      */
@@ -4672,8 +4681,8 @@ public final  Observable groupJoin(Observable right, Func1
      * 
    
      * 
      * 
-     * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on
-     *         which one is called by the source Observable
+     * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on which one is
+     *         called by the source Observable
      * @see RxJava Wiki: ignoreElements()
      * @see MSDN: Observable.IgnoreElements
      */
@@ -4684,8 +4693,8 @@ public final Observable ignoreElements() {
     /**
      * Returns an Observable that emits {@code true} if the source Observable is empty, otherwise {@code false}.
      * 
    
-     * In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better
-     * match Java naming idioms.
+     * In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better match Java
+     * naming idioms.
      * 
    
      * 
      * 
@@ -4705,15 +4714,16 @@ public final Observable isEmpty() {
      * @param right
      *            the second Observable to join items from
      * @param leftDurationSelector
-     *            a function to select a duration for each item emitted by the source Observable,
-     *            used to determine overlap
+     *            a function to select a duration for each item emitted by the source Observable, used to
+     *            determine overlap
      * @param rightDurationSelector
-     *            a function to select a duration for each item emitted by the {@code right} Observable, used to determine overlap
+     *            a function to select a duration for each item emitted by the {@code right} Observable, used to
+     *            determine overlap
      * @param resultSelector
-     *            a function that computes an item to be emitted by the resulting Observable for any
-     *            two overlapping items emitted by the two Observables
-     * @return an Observable that emits items correlating to items emitted by the source Observables
-     *         that have overlapping durations
+     *            a function that computes an item to be emitted by the resulting Observable for any two
+     *            overlapping items emitted by the two Observables
+     * @return an Observable that emits items correlating to items emitted by the source Observables that have
+     *         overlapping durations
      * @see RxJava Wiki: join()
      * @see MSDN: Observable.Join
      */
@@ -4724,13 +4734,13 @@ public final  Observable join(Obser
     }
 
     /**
-     * Returns an Observable that emits the last item emitted by the source Observable or notifies
-     * observers of an {@code IllegalArgumentException} if the source Observable is empty.
+     * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
+     * an {@code IllegalArgumentException} if the source Observable is empty.
      * 
    
      * 
      * 
-     * @return an Observable that emits the last item from the source Observable or notifies
-     *         observers of an error
+     * @return an Observable that emits the last item from the source Observable or notifies observers of an
+     *         error
      * @see RxJava Wiki: last()
      * @see MSDN: {@code Observable.lastAsync()}
      */
@@ -4739,16 +4749,15 @@ public final Observable last() {
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source Observable that
-     * satisfies a given condition, or an {@code IllegalArgumentException} if no such items are
-     * emitted.
+     * Returns an Observable that emits only the last item emitted by the source Observable that satisfies a
+     * given condition, or an {@code IllegalArgumentException} if no such items are emitted.
      * 
    
      * 
      * 
      * @param predicate
      *            the condition any source emitted item has to satisfy
-     * @return an Observable that emits only the last item satisfying the given condition from the
-     *         source, or an {@code IllegalArgumentException} if no such items are emitted
+     * @return an Observable that emits only the last item satisfying the given condition from the source, or an
+     *         {@code IllegalArgumentException} if no such items are emitted
      * @throws IllegalArgumentException
      *             if no items that match the predicate are emitted by the source Observable
      * @see RxJava Wiki: last()
@@ -4759,15 +4768,15 @@ public final Observable last(Func1 predicate) {
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source Observable, or a
-     * default item if the source Observable completes without emitting any items.
+     * Returns an Observable that emits only the last item emitted by the source Observable, or a default item
+     * if the source Observable completes without emitting any items.
      * 
    
      * 
      * 
      * @param defaultValue
      *            the default item to emit if the source Observable is empty
-     * @return an Observable that emits only the last item emitted by the source Observable, or a
-     *         default item if the source Observable is empty
+     * @return an Observable that emits only the last item emitted by the source Observable, or a default item
+     *         if the source Observable is empty
      * @see RxJava Wiki: lastOrDefault()
      * @see MSDN: {@code Observable.lastOrDefaultAsync()}
      */
@@ -4776,20 +4785,18 @@ public final Observable lastOrDefault(T defaultValue) {
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source Observable that
-     * satisfies a specified condition, or a default item if no such item is emitted by the source
-     * Observable.
+     * Returns an Observable that emits only the last item emitted by the source Observable that satisfies a
+     * specified condition, or a default item if no such item is emitted by the source Observable.
      * 
    
      * 
      * 
      * @param defaultValue
-     *            the default item to emit if the source Observable doesn't emit anything that
-     *            satisfies the specified {@code predicate}
+     *            the default item to emit if the source Observable doesn't emit anything that satisfies the
+     *            specified {@code predicate}
      * @param predicate
      *            the condition any item emitted by the source Observable has to satisfy
-     * @return an Observable that emits only the last item emitted by the source Observable that
-     *         satisfies the given condition, or a default item if no such item is emitted by the
-     *         source Observable
+     * @return an Observable that emits only the last item emitted by the source Observable that satisfies the
+     *         given condition, or a default item if no such item is emitted by the source Observable
      * @see RxJava Wiki: lastOrDefault()
      * @see MSDN: {@code Observable.lastOrDefaultAsync()}
      */
@@ -4798,13 +4805,13 @@ public final Observable lastOrDefault(T defaultValue, Func1
      * 
      * 
-     * @return an Observable that emits a single item: the number of items emitted by the source
-     *         Observable as a 64-bit Long item
+     * @return an Observable that emits a single item: the number of items emitted by the source Observable as a
+     *         64-bit Long item
      * @see RxJava Wiki: count()
      * @see MSDN: Observable.LongCount
      * @see #count()
@@ -4819,15 +4826,15 @@ public final Long call(Long t1, T t2) {
     }
 
     /**
-     * Returns an Observable that applies a specified function to each item emitted by the source
-     * Observable and emits the results of these function applications.
+     * Returns an Observable that applies a specified function to each item emitted by the source Observable and
+     * emits the results of these function applications.
      * 
    
      * 
      * 
      * @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
-     *         specified function
+     * @return an Observable that emits the items from the source Observable, transformed by the specified
+     *         function
      * @see RxJava Wiki: map()
      * @see MSDN: Observable.Select
      */
@@ -4836,20 +4843,20 @@ public final  Observable map(Func1 func) {
     }
 
     /**
-     * Returns 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.
+     * Returns 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 these transformations
+     *            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 these
+     *         transformations
      * @see RxJava Wiki: mapMany()
      * @see #flatMap(Func1)
      * @deprecated use {@link #flatMap(Func1)}
@@ -4860,13 +4867,13 @@ public final  Observable mapMany(Func1>
     }
 
     /**
-     * Turns all of the emissions and notifications from a source Observable into emissions marked
-     * with their original types within {@link Notification} objects.
+     * Turns all of the emissions and notifications from a source Observable into emissions marked with their
+     * original types within {@link Notification} objects.
      * 
    
      * 
      * 
-     * @return an Observable that emits items that are the result of materializing the items and
-     *         notifications of the source Observable
+     * @return an Observable that emits items that are the result of materializing the items and notifications
+     *         of the source Observable
      * @see RxJava Wiki: materialize()
      * @see MSDN: Observable.materialize
      */
@@ -4875,16 +4882,16 @@ public final Observable> materialize() {
     }
 
     /**
-     * Returns an Observable that emits the maximum item emitted by the source Observable, according
-     * to the specified comparator. If there is more than one item with the same maximum value, it
-     * emits the last-emitted of these.
+     * Returns an Observable that emits the maximum item emitted by the source Observable, according to the
+     * specified comparator. If there is more than one item with the same maximum value, it emits the
+     * last-emitted of these.
      * 
    
      * 
      * 
      * @param comparator
      *            the comparer used to compare items
-     * @return an Observable that emits the maximum item emitted by the source Observable, according
-     *         to the specified comparator
+     * @return an Observable that emits the maximum item emitted by the source Observable, according to the
+     *         specified comparator
      * @throws IllegalArgumentException
      *             if the source is empty
      * @see RxJava Wiki: max()
@@ -4895,16 +4902,15 @@ public final Observable max(Comparator comparator) {
     }
 
     /**
-     * Returns an Observable that emits a List of items emitted by the source Observable that have
-     * the maximum key value. For a source Observable that emits no items, the resulting Observable
-     * emits an empty List.
+     * Returns an Observable that emits a List of items emitted by the source Observable that have the maximum
+     * key value. For a source Observable that emits no items, the resulting Observable emits an empty List.
      * 
    
      * 
      * 
      * @param selector
      *            this function accepts an item emitted by the source Observable and returns a key
-     * @return an Observable that emits a List of those items emitted by the source Observable that
-     *         had the largest key value of all of the emitted items
+     * @return an Observable that emits a List of those items emitted by the source Observable that had the
+     *         largest key value of all of the emitted items
      * @see RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
@@ -4913,9 +4919,9 @@ public final > Observable> maxBy(Func1
      * 
      * 
@@ -4923,9 +4929,8 @@ public final > Observable> maxBy(Func1RxJava Wiki: maxBy()
      * @see MSDN: Observable.MaxBy
      */
@@ -4934,18 +4939,18 @@ public final  Observable> maxBy(Func1 selector, Comparator
      * 
      * 
      * @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 these transformations
+     *            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 these
+     *         transformations
      * @see RxJava Wiki: flatMap()
      * @see #flatMap(Func1)
      */
@@ -4954,26 +4959,23 @@ public final  Observable mergeMap(Func1
      * 
      * 
      * @param 
      *            the result type
      * @param onNext
-     *            a function that returns an Observable to merge for each item emitted by the source
-     *            Observable
+     *            a function that returns an Observable to merge for each item emitted by the source Observable
      * @param onError
-     *            a function that returns an Observable to merge for an onError notification from
-     *            the source Observable
+     *            a function that returns an Observable to merge for an onError notification from the source
+     *            Observable
      * @param onCompleted
-     *            a function that returns an Observable to merge for an onCompleted notification
-     *            from the source Observable
-     * @return an Observable that emits the results of merging the Observables returned from
-     *         applying the specified functions to the emissions and notifications of the source
-     *         Observable
+     *            a function that returns an Observable to merge for an onCompleted notification from the source
+     *            Observable
+     * @return an Observable that emits the results of merging the Observables returned from applying the
+     *         specified functions to the emissions and notifications of the source Observable
      */
     public final  Observable mergeMap(
             Func1> onNext,
@@ -4983,8 +4985,8 @@ public final  Observable mergeMap(
     }
 
     /**
-     * Returns an Observable that emits the results of a specified function to the pair of values
-     * emitted by the source Observable and a specified collection Observable.
+     * Returns an Observable that emits the results of a specified function to the pair of values emitted by the
+     * source Observable and a specified collection Observable.
      * 
    
      * 
      * 
@@ -4993,13 +4995,12 @@ public final  Observable mergeMap(
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param collectionSelector
-     *            a function that returns an Observable for each item emitted by the source
-     *            Observable
+     *            a function that returns an Observable for each item emitted by the source Observable
      * @param resultSelector
-     *            a function that combines one item emitted by each of the source and collection
-     *            Observables and returns an item to be emitted by the resulting Observable
-     * @return an Observable that emits the results of applying a function to a pair of values
-     *         emitted by the source Observable and the collection Observable
+     *            a function that combines one item emitted by each of the source and collection Observables and
+     *            returns an item to be emitted by the resulting Observable
+     * @return an Observable that emits the results of applying a function to a pair of values emitted by the
+     *         source Observable and the collection Observable
      */
     public final  Observable mergeMap(Func1> collectionSelector,
             Func2 resultSelector) {
@@ -5007,28 +5008,27 @@ public final  Observable mergeMap(Func1
      * 
      * 
      * @param 
      *            the type of item emitted by the resulting Observable
      * @param collectionSelector
-     *            a function that returns an Iterable sequence of values for when given an item
-     *            emitted by the source Observable
-     * @return an Observable that emits the results of merging the items emitted by the source
-     *         Observable with the values in the Iterables corresponding to those items, as
-     *         generated by {@code collectionSelector}
+     *            a function that returns an Iterable sequence of values for when given an item emitted by the
+     *            source Observable
+     * @return an Observable that emits the results of merging the items emitted by the source Observable with
+     *         the values in the Iterables corresponding to those items, as generated by
+     *         {@code collectionSelector}
      */
     public final  Observable mergeMapIterable(Func1> collectionSelector) {
         return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
     }
 
     /**
-     * Returns an Observable that emits the results of applying a function to the pair of values
-     * from the source Observable and an Iterable corresponding to that item that is generated by
-     * a selector.
+     * Returns an Observable that emits the results of applying a function to the pair of values from the source
+     * Observable and an Iterable corresponding to that item that is generated by a selector.
      * 
    
      * 
      * 
@@ -5037,13 +5037,13 @@ public final  Observable mergeMapIterable(Func1
      *            the type of item emited by the resulting Observable
      * @param collectionSelector
-     *            a function that returns an Iterable sequence of values for each item emitted by
-     *            the source Observable
+     *            a function that returns an Iterable sequence of values for each item emitted by the source
+     *            Observable
      * @param resultSelector
-     *            a function that returns an item based on the item emitted by the source Observable
-     *            and the Iterable returned for that item by the {@code collectionSelector}
-     * @return an Observable that emits the items returned by {@code resultSelector} for each item
-     *         in the source Observable
+     *            a function that returns an item based on the item emitted by the source Observable and the
+     *            Iterable returned for that item by the {@code collectionSelector}
+     * @return an Observable that emits the items returned by {@code resultSelector} for each item in the source
+     *         Observable
      */
     public final  Observable mergeMapIterable(Func1> collectionSelector,
             Func2 resultSelector) {
@@ -5051,16 +5051,15 @@ public final  Observable mergeMapIterable(Func1
      * 
      * 
      * @param comparator
      *            the comparer used to compare elements
-     * @return an Observable that emits the minimum item emitted by the source Observable according
-     *         to the specified comparator
+     * @return an Observable that emits the minimum item emitted by the source Observable according to the
+     *         specified comparator
      * @throws IllegalArgumentException
      *             if the source is empty
      * @see RxJava Wiki: min()
@@ -5071,16 +5070,15 @@ public final Observable min(Comparator comparator) {
     }
 
     /**
-     * Returns an Observable that emits a List of items emitted by the source Observable that have
-     * the minimum key value. For a source Observable that emits no items, the resulting Observable
-     * emits an empty List.
+     * Returns an Observable that emits a List of items emitted by the source Observable that have the minimum
+     * key value. For a source Observable that emits no items, the resulting Observable emits an empty List.
      * 
    
      * 
      * 
      * @param selector
      *            the key selector function
-     * @return an Observable that emits a List of all of the items from the source Observable that
-     *         had the lowest key value of any items emitted by the source Observable
+     * @return an Observable that emits a List of all of the items from the source Observable that had the
+     *         lowest key value of any items emitted by the source Observable
      * @see RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
@@ -5089,9 +5087,9 @@ public final > Observable> minBy(Func1
      * 
      * 
@@ -5099,9 +5097,9 @@ public final > Observable> minBy(Func1RxJava Wiki: minBy()
      * @see MSDN: Observable.MinBy
      */
@@ -5110,16 +5108,16 @@ public final  Observable> minBy(Func1 selector, ComparatorRxJava: Observable.publish() and Observable.multicast()
      * @see MSDN: Observable.Multicast
      */
@@ -5130,16 +5128,15 @@ public final  Observable multicast(
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that upon connection causes the source Observable to
-     * push results into the specified subject.
+     * 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
+     *            the {@link Subject} for the {@link ConnectableObservable} to push source items into
      * @param 
      *            the type of items emitted by the resulting {@code ConnectableObservable}
-     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to
-     *         push results into the specified {@link Subject}
+     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to push results
+     *         into the specified {@link Subject}
      * @see RxJava Wiki: Observable.publish() and Observable.multicast()
      */
     public final  ConnectableObservable multicast(Subject subject) {
@@ -5147,14 +5144,14 @@ public final  ConnectableObservable multicast(Subject
      * 
      * 
      * @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}
+     * @return the source Observable modified so that its {@link Observer}s are notified on the specified
+     *         {@link Scheduler}
      * @see RxJava Wiki: observeOn()
      */
     public final Observable observeOn(Scheduler scheduler) {
@@ -5162,16 +5159,18 @@ public final Observable observeOn(Scheduler scheduler) {
     }
 
     /**
-     * Move notifications to the specified {@link Scheduler} asynchronously with a buffer of the given size.
+     * Move notifications to the specified {@link Scheduler} asynchronously with a buffer of a specified size.
      * 
    
      * 
+     * 
    
+     * If the buffer fills to its maximum size...
      * 
      * @param scheduler
      *            the {@link Scheduler} to notify {@link Observer}s on
      * @param bufferSize
      *            that will be rounded up to the next power of 2
-     * @return the source Observable modified so that its {@link Observer}s are notified on the
-     *         specified {@link Scheduler}
+     * @return the source Observable modified so that its {@link Observer}s are notified on the specified
+     *         {@link Scheduler}
      * @see RxJava Wiki: observeOn()
      */
     public final Observable observeOn(Scheduler scheduler, int bufferSize) {
@@ -5198,26 +5197,27 @@ public final Boolean call(T t) {
     }
 
     /**
-     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error.
+     * 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 {@code onError} method, and then quits without invoking any more of its Observer's methods. The
-     * {@code onErrorResumeNext} method changes this behavior. If you pass a function that returns
-     * an Observable ({@code resumeFunction}) to {@code onErrorResumeNext}, if the original
-     * Observable encounters an error, instead of invoking its Observer's {@code onError} method, it
-     * will instead relinquish control to the Observable returned from {@code 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 {@code onError}, the Observer may
-     * never know that an error happened.
+     * 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 {@code onError} method, and then quits
+     * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this
+     * behavior. If you pass a function that returns an Observable ({@code resumeFunction}) to
+     * {@code onErrorResumeNext}, if the original Observable encounters an error, instead of invoking its
+     * Observer's {@code onError} method, it will instead relinquish control to the Observable returned from
+     * {@code 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 {@code 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.
+     * 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
+     *            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
      * @see RxJava Wiki: onErrorResumeNext()
      */
@@ -5226,25 +5226,27 @@ public final Observable onErrorResumeNext(final Func1
      * 
      * 
    
-     * 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 {@code onError} method, and then quits without invoking any more of its Observer's methods. The
-     * {@code onErrorResumeNext} method changes this behavior. If you pass another Observable
-     * ({@code resumeSequence}) to an Observable's {@code onErrorResumeNext} method, if the original
-     * Observable encounters an error, instead of invoking its Observer's {@code onError} method, it
-     * will instead relinquish control to {@code 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 {@code onError}, the Observer may never know that 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 {@code onError} method, and then quits
+     * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this
+     * behavior. If you pass another Observable ({@code resumeSequence}) to an Observable's
+     * {@code onErrorResumeNext} method, if the original Observable encounters an error, instead of invoking its
+     * Observer's {@code onError} method, it will instead relinquish control to {@code 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 {@code 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.
+     * 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
+     *            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
      * @see RxJava Wiki: onErrorResumeNext()
      */
@@ -5253,24 +5255,24 @@ public final Observable onErrorResumeNext(final Observable resum
     }
 
     /**
-     * Instruct an Observable to emit an item (returned by a specified function) rather than
-     * invoking {@link Observer#onError onError} if it encounters an error.
+     * 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 {@code onError} method, and then quits without invoking any more of its Observer's methods. The
-     * {@code onErrorReturn} method changes this behavior. If you pass a function
-     * ({@code resumeFunction}) to an Observable's {@code onErrorReturn} method, if the original
-     * Observable encounters an error, instead of invoking its Observer's {@code onError} method, it
-     * will instead emit the return value of {@code resumeFunction}.
+     * 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 {@code onError} method, and then quits
+     * without invoking any more of its Observer's methods. The {@code onErrorReturn} method changes this
+     * behavior. If you pass a function ({@code resumeFunction}) to an Observable's {@code onErrorReturn}
+     * method, if the original Observable encounters an error, instead of invoking its Observer's
+     * {@code onError} method, it will instead emit the return value of {@code resumeFunction}.
      * 
    
-     * You can use this to prevent errors from propagating or to supply fallback data should errors
-     * be encountered.
+     * 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
+     *            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
      * @see RxJava Wiki: onErrorReturn()
      */
@@ -5279,27 +5281,30 @@ public final Observable onErrorReturn(Func1 resumeFun
     }
 
     /**
-     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an {@link java.lang.Exception}.
+     * Instruct an Observable to pass control to another Observable rather than invoking
+     * {@link Observer#onError onError} if it encounters an {@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.
+     * 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 exception that prevents it from emitting the
-     * expected item to its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits without invoking any more of its Observer's methods. The
-     * {@code onExceptionResumeNext} method changes this behavior. If you pass another Observable
-     * ({@code resumeSequence}) to an Observable's {@code onExceptionResumeNext} method, if the
-     * original Observable encounters an exception, instead of invoking its Observer's {@code onError} method, it will instead relinquish control to {@code 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 {@code onError}, the Observer may
-     * never know that an exception happened.
+     * By default, when an Observable encounters an exception that prevents it from emitting the expected item
+     * to its {@link Observer}, the Observable invokes its Observer's {@code onError} method, and then quits
+     * without invoking any more of its Observer's methods. The {@code onExceptionResumeNext} method changes
+     * this behavior. If you pass another Observable ({@code resumeSequence}) to an Observable's
+     * {@code onExceptionResumeNext} method, if the original Observable encounters an exception, instead of
+     * invoking its Observer's {@code onError} method, it will instead relinquish control to
+     * {@code 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 {@code onError}, the Observer
+     * may never know that an exception happened.
      * 
    
-     * You can use this to prevent exceptions from propagating or to supply fallback data should
-     * exceptions be encountered.
+     * You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be
+     * encountered.
      * 
      * @param resumeSequence
-     *            a function that returns an Observable that will take over if the source Observable
-     *            encounters an exception
+     *            a function that returns an Observable that will take over if the source Observable encounters
+     *            an exception
      * @return the original Observable, with appropriately modified behavior
      * @see RxJava Wiki: onExceptionResumeNext()
      */
@@ -5308,15 +5313,16 @@ public final Observable onExceptionResumeNext(final Observable r
     }
 
     /**
-     * Perform work on the source {@code Observable} in parallel by sharding it on a {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable}.
+     * Perform work on the source {@code Observable} in parallel by sharding it on a
+     * {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable}.
      * 
    
      * 
      * 
      * @param f
-     *            a {@link Func1} that applies Observable Observers to {@code Observable} in
-     *            parallel and returns an {@code Observable}
-     * @return an Observable that emits the results of applying {@link Func1} to the items emitted
-     *         by the source Observable
+     *            a {@link Func1} that applies Observable Observers to {@code Observable} in parallel and
+     *            returns an {@code Observable}
+     * @return an Observable that emits the results of applying {@link f} to the items emitted by the source
+     *         Observable
      * @see RxJava Wiki: parallel()
      */
     public final  Observable parallel(Func1, Observable> f) {
@@ -5326,17 +5332,18 @@ public final  Observable parallel(Func1, Observable> f) {
     }
 
     /**
-     * Perform work on the source {@code Observable} in parallel by sharding it on a {@link Scheduler}, and return the resulting {@code Observable}.
+     * Perform work on the source {@code Observable} in parallel by sharding it on a {@link Scheduler}, and
+     * return the resulting {@code Observable}.
      * 
    
      * 
      * 
      * @param f
-     *            a {@link Func1} that applies Observable Observers to {@code Observable} in
-     *            parallel and returns an {@code Observable}
+     *            a {@link Func1} that applies Observable Observers to {@code Observable} in parallel and
+     *            returns an {@code Observable}
      * @param s
      *            a {@link Scheduler} to perform the work on
-     * @return an Observable that emits the results of applying {@link Func1} to the items emitted
-     *         by the source Observable
+     * @return an Observable that emits the results of applying {@link f} to the items emitted by the source
+     *         Observable
      * @see RxJava Wiki: parallel()
      */
     public final  Observable parallel(final Func1, Observable> f, final Scheduler s) {
@@ -5347,21 +5354,22 @@ public final  Observable parallel(final Func1, Observable
      * Protects against errors being thrown from Observer implementations and ensures
      * onNext/onError/onCompleted contract compliance.
      * 
    
-     * See https://github.com/Netflix/RxJava/issues/216 for a discussion on "Guideline 6.4: Protect
-     * calls to user code from within an Observer"
+     * See https://github.com/Netflix/RxJava/issues/216 for a discussion on "Guideline 6.4: Protect calls to
+     * user code from within an Observer"
      */
     private Subscription protectivelyWrapAndSubscribe(Subscriber o) {
         return subscribe(new SafeSubscriber(o));
     }
 
     /**
-     * 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.
+     * 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
+     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit items
+     *         to its {@link Observer}s
      * @see RxJava Wiki: publish()
      */
     public final ConnectableObservable publish() {
@@ -5369,22 +5377,19 @@ public final ConnectableObservable publish() {
     }
 
     /**
-     * Returns an Observable that emits the results of invoking a specified selector on items
-     * emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying sequence.
+     * Returns an Observable that emits the results of invoking a specified selector on items emitted by a
+     * {@link ConnectableObservable} that shares a single subscription to the underlying sequence.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a function that can use the multicasted source sequence as many times as needed,
-     *            without causing multiple subscriptions to the source sequence. Subscribers to the
-     *            given source will receive all notifications of the source from the time of the
-     *            subscription forward.
-     * @return an Observable that emits the results of invoking the selector on the items emitted by
-     *         a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         sequence
+     *            a function that can use the multicasted source sequence as many times as needed, without
+     *            causing multiple subscriptions to the source sequence. Subscribers to the given source will
+     *            receive all notifications of the source from the time of the subscription forward.
+     * @return an Observable that emits the results of invoking the selector on the items emitted by a
+     *         {@link ConnectableObservable} that shares a single subscription to the underlying sequence
      */
     public final  Observable publish(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
@@ -5396,25 +5401,22 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits the results of invoking a specified selector on items
-     * emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable that shares a single subscription to the underlying sequence and starts
-     * with {@code initialValue}.
+     * Returns an Observable that emits {@code initialValue} followed by the results of invoking a specified
+     * selector on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
+     * source Observable.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a function that can use the multicasted source sequence as many times as needed,
-     *            without causing multiple subscriptions to the source Observable. Subscribers to
-     *            the source will receive all notifications of the source from the time of the
-     *            subscription forward
+     *            a function that can use the multicasted source sequence as many times as needed, without
+     *            causing multiple subscriptions to the source Observable. Subscribers to the source will
+     *            receive all notifications of the source from the time of the subscription forward
      * @param initialValue
      *            the initial value of the underlying {@link BehaviorSubject}
-     * @return an Observable that emits {@code initialValue} followed by the results of invoking the
-     *         selector on a {@ConnectableObservable} that shares a single subscription to the
-     *         underlying sequence
+     * @return an Observable that emits {@code initialValue} followed by the results of invoking the selector
+     *         on a {@ConnectableObservable} that shares a single subscription to the underlying Observable
      */
     public final  Observable publish(Func1, ? extends Observable> selector, final T initialValue) {
         return multicast(new Func0>() {
@@ -5426,28 +5428,26 @@ public final Subject call() {
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying
-     * Observable and starts with {@code initialValue}.
+     * Returns an Observable that emits {@code initialValue} followed by the items emitted by a
+     * {@link ConnectableObservable} that shares a single subscription to the source Observable.
      * 
    
      * 
      * 
      * @param initialValue
-     *            the initial value of the underlying {@link BehaviorSubject}
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and starts with {@code initialValue}
+     *            the initial value to be emitted by the resulting Observable
+     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying Observable
+     *         and starts with {@code initialValue}
      */
     public final ConnectableObservable publish(T initialValue) {
         return OperationMulticast.multicast(this, BehaviorSubject. create(initialValue));
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source
-     * Observable.
+     * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source Observable.
      * 
    
      * 
      * 
-     * @return a {@link ConnectableObservable} that emits only the last item emitted by the source
-     *         Observable
+     * @return a {@link ConnectableObservable} that emits only the last item emitted by the source Observable
      * @see RxJava Wiki: publishLast()
      */
     public final ConnectableObservable publishLast() {
@@ -5455,20 +5455,19 @@ public final ConnectableObservable publishLast() {
     }
 
     /**
-     * Retusna an Observable that emits items that are results of invoking a specified selector on
-     * items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying sequence but contains only its last emission.
+     * Returns an Observable that emits an item that results from invoking a specified selector on the last item
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a function that can use the multicasted source sequence as many times as needed,
-     *            without causing multiple subscriptions to the source Observable. Subscribers to
-     *            the source will only receive the last item emitted by the source.
-     * @return an Observable that emits items that are the result of invoking the selector on a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable but contains only its last emission.
+     *            a function that can use the multicasted source sequence as many times as needed, without
+     *            causing multiple subscriptions to the source Observable. Subscribers to the source will only
+     *            receive the last item emitted by the source.
+     * @return an Observable that emits an item that is the result of invoking the selector on a
+     *         {@link ConnectableObservable} that shares a single subscription to the source Observable
      */
     public final  Observable publishLast(Func1, ? extends Observable> selector) {
         return multicast(new Func0>() {
@@ -5480,23 +5479,22 @@ public final Subject call() {
     }
 
     /**
-     * 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.
+     * 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" here, is sometimes called "aggregate," "fold,"
-     * "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance,
-     * has an {@code inject()} method that does a similar operation on lists.
+     * This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate,"
+     * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code 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 items
-     *         emitted by the source Observable
+     *            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 items emitted by
+     *         the source Observable
      * @throws IllegalArgumentException
      *             if the source Observable emits no items
      * @see RxJava Wiki: reduce()
@@ -5508,32 +5506,30 @@ public final Observable reduce(Func2 accumulator) {
          * Discussion and confirmation of implementation at
          * https://github.com/Netflix/RxJava/issues/423#issuecomment-27642532
          * 
-         * It should use last() not takeLast(1) since it needs to emit an error if the sequence is
-         * empty.
+         * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
         return scan(accumulator).last();
     }
 
     /**
-     * Returns an Observable that applies a function of your choosing to the first item emitted by a
-     * source Observable and a specified seed value, 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.
+     * Returns an Observable that applies a function of your choosing to the first item emitted by a source
+     * Observable and a specified seed value, 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" here, is sometimec called "aggregate," "fold,"
-     * "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance,
-     * has an {@code inject()} method that does a similar operation on lists.
+     * This technique, which is called "reduce" here, is sometimec called "aggregate," "fold," "accumulate,"
+     * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code 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
+     *            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 RxJava Wiki: reduce()
      * @see MSDN: Observable.Aggregate
      * @see Wikipedia: Fold (higher-order function)
@@ -5543,13 +5539,11 @@ public final  Observable reduce(R initialValue, Func2 acc
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable
-     * indefinitely.
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
      * 
    
      * 
      * 
-     * @return an Observable that emits the items emitted by the source Observable repeatedly and in
-     *         sequence
+     * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
@@ -5558,15 +5552,14 @@ public final Observable repeat() {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable
-     * indefinitely, on a particular scheduler.
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely,
+     * on a particular Scheduler.
      * 
    
      * 
      * 
      * @param scheduler
-     *            the scheduler to emit the items on
-     * @return an Observable that emits the items emitted by the source Observable repeatedly and in
-     *         sequence
+     *            the Scheduler to emit the items on
+     * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
@@ -5575,16 +5568,16 @@ public final Observable repeat(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source
-     * Observable at most count times.
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most
+     * {@code count} times.
      * 
    
      * 
      * 
      * @param count
-     *            the number of times the source Observable items are repeated,
-     *            a count of 0 will yield an empty sequence
-     * @return an Observable that repeats the sequence of items emitted by the source
-     *         Observable at most {@code count} times
+     *            the number of times the source Observable items are repeated, a count of 0 will yield an empty
+     *            sequence
+     * @return an Observable that repeats the sequence of items emitted by the source Observable at most
+     *         {@code count} times
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
@@ -5596,18 +5589,18 @@ public final Observable repeat(long count) {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source
-     * Observable at most count times on a particular scheduler.
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most
+     * {@code count} times, on a particular Scheduler.
      * 
    
      * 
      * 
      * @param count
-     *            the number of times the source Observable items are repeated,
-     *            a count of 0 will yield an empty sequence.
+     *            the number of times the source Observable items are repeated, a count of 0 will yield an empty
+     *            sequence
      * @param scheduler
      *            the {@link Scheduler} to emit the items on
-     * @return an Observable that repeats the sequence of items emitted by the source
-     *         Observable at most {@code count} times on a particular Scheduler
+     * @return an Observable that repeats the sequence of items emitted by the source Observable at most
+     *         {@code count} times on a particular Scheduler
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
@@ -5616,13 +5609,13 @@ public final Observable repeat(long count, Scheduler scheduler) {
     }
 
     /**
-     * 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}.
+     * 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 its items to its {@link Observer}s
+     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit its
+     *         items to its {@link Observer}s
      * @see RxJava Wiki: replay()
      */
     public final ConnectableObservable replay() {
@@ -5630,19 +5623,18 @@ public final ConnectableObservable replay() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on the items emitted by a {@link ConnectableObservable} that shares a single subscription to
-     * the underlying Observable.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on the items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            the selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
-     * @return an Observable that emits items that are the results of invoking the selector on a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable
+     *            the selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
+     * @return an Observable that emits items that are the results of invoking the selector on a
+     *         {@link ConnectableObservable} that shares a single subscription to the source Observable
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5656,23 +5648,22 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying {@code bufferSize} notifications.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying {@code bufferSize} notifications.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            the selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            the selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param bufferSize
-     *            the buffer size that limits the number of items the connectable observable can
-     *            replay
-     * @return an Observable that emits items that are the results of invoking the selector on
-     *         items emitted by a {@link ConnectableObservable} that shares a single subscription to
-     *         the underlying Observable replaying no more than {@code bufferSize} items
+     *            the buffer size that limits the number of items the connectable observable can replay
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable
+     *         replaying no more than {@code bufferSize} items
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5686,29 +5677,27 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying no more than {@code bufferSize} items that were emitted
-     * within a specified time window.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying no more than {@code bufferSize} items that were emitted within a specified time window.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param bufferSize
-     *            the buffer size that limits the number of items the connectable observable can
-     *            replay
+     *            the buffer size that limits the number of items the connectable observable can replay
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, and replay no more than {@code bufferSize} items that were
-     *         emitted within the window defined by {@code time}
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable, and
+     *         replays no more than {@code bufferSize} items that were emitted within the window defined by
+     *         {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5717,31 +5706,29 @@ public final  Observable replay(Func1, ? extends Obs
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying no more than {@code bufferSize} items that were emitted
-     * within a specified time window.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying no more than {@code bufferSize} items that were emitted within a specified time window.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param bufferSize
-     *            the buffer size that limits the number of items the connectable observable can
-     *            replay
+     *            the buffer size that limits the number of items the connectable observable can replay
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
      * @param scheduler
-     *            the scheduler that is the time source for the window
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, and replay no more than {@code bufferSize} items that were
-     *         emitted within the window defined by {@code time}
+     *            the Scheduler that is the time source for the window
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable, and
+     *         replays no more than {@code bufferSize} items that were emitted within the window defined by
+     *         {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5758,25 +5745,24 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying a maximum of {@code bufferSize} items.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying a maximum of {@code bufferSize} items.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param bufferSize
-     *            the buffer size that limits the number of items the connectable observable can
-     *            replay
+     *            the buffer size that limits the number of items the connectable observable can replay
      * @param scheduler
-     *            the scheduler on which the replay is observed
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, replaying no more than {@code bufferSize} notifications
+     *            the Scheduler on which the replay is observed
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     *         replaying no more than {@code bufferSize} notifications
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5790,25 +5776,24 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying all items that were emitted within a specified time window.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying all items that were emitted within a specified time window.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, replaying all items that were emitted within the window
-     *         defined by {@code time}
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     *         replaying all items that were emitted within the window defined by {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5817,27 +5802,26 @@ public final  Observable replay(Func1, ? extends Obs
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable, replaying all items that were emitted within a specified time window.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     * replaying all items that were emitted within a specified time window.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
      * @param scheduler
      *            the scheduler that is the time source for the window
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, replaying all items that were emitted within the window
-     *         defined by {@code time}
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     *         replaying all items that were emitted within the window defined by {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5851,22 +5835,21 @@ public final Subject call() {
     }
 
     /**
-     * Returns an Observable that emits items that are the results of invoking a specified selector
-     * on items emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     * underlying Observable.
+     * Returns an Observable that emits items that are the results of invoking a specified selector on items
+     * emitted by a {@link ConnectableObservable} that shares a single subscription to the source Observable.
      * 
    
      * 
      * 
      * @param 
      *            the type of items emitted by the resulting Observable
      * @param selector
-     *            a selector function, which can use the multicasted sequence as many times as
-     *            needed, without causing multiple subscriptions to the Observable
+     *            a selector function, which can use the multicasted sequence as many times as needed, without
+     *            causing multiple subscriptions to the Observable
      * @param scheduler
-     *            the scheduler where the replay is observed
-     * @return an Observable that emits items that are the results of invoking the selector on items
-     *         emitted by a {@link ConnectableObservable} that shares a single subscription to the
-     *         underlying Observable, replaying all items
+     *            the Scheduler where the replay is observed
+     * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+     *         a {@link ConnectableObservable} that shares a single subscription to the source Observable,
+     *         replaying all items
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5880,15 +5863,15 @@ public final Subject call() {
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source
-     * Observable that replays at most {@code bufferSize} items emitted by that Observable.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that
+     * replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
      * 
      * 
      * @param bufferSize
      *            the buffer size that limits the number of items that can be replayed
-     * @return a {@link ConnectableObservable} that shares a single subscription to the source
-     *         Observable and replays at most {@code bufferSize} items emitted by that Observable
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays at most {@code bufferSize} items emitted by that Observable
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5897,9 +5880,8 @@ public final ConnectableObservable replay(int bufferSize) {
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying
-     * Observable and replays at most {@code bufferSize} items that were emitted during a specified
-     * time window.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * replays at most {@code bufferSize} items that were emitted during a specified time window.
      * 
    
      * 
      * 
@@ -5909,9 +5891,9 @@ public final ConnectableObservable replay(int bufferSize) {
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and replays at most {@code bufferSize} items that were emitted during the
-     *         window defined by {@code time}
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays at most {@code bufferSize} items that were emitted during the window defined by
+     *         {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5920,9 +5902,8 @@ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying
-     * Observable and that replays a maximum of {@code bufferSize} items that are emitted within
-     * a specified time window.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window.
      * 
    
      * 
      * 
@@ -5934,9 +5915,9 @@ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit
      *            the time unit of {@code time}
      * @param scheduler
      *            the scheduler that is used as a time source for the window
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and replays at most {@code bufferSize} items that were emitted during the
-     *         window defined by {@code time}
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays at most {@code bufferSize} items that were emitted during the window defined by
+     *         {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5948,8 +5929,8 @@ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source
-     * Observable and replays at most {@code bufferSize} items emitted by that Observable.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * replays at most {@code bufferSize} items emitted by that Observable.
      * 
    
      * 
      * 
@@ -5957,9 +5938,8 @@ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit
      *            the buffer size that limits the number of items that can be replayed
      * @param scheduler
      *            the scheduler on which the Observers will observe the emitted items
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and replays at most {@code bufferSize} items that were emitted by the
-     *         Observable
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays at most {@code bufferSize} items that were emitted by the Observable
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5970,8 +5950,8 @@ public final ConnectableObservable replay(int bufferSize, Scheduler scheduler
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source
-     * Observable and replays all items emitted by that Observable within a specified time window.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * replays all items emitted by that Observable within a specified time window.
      * 
    
      * 
      * 
@@ -5979,8 +5959,8 @@ public final ConnectableObservable replay(int bufferSize, Scheduler scheduler
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and replays the items that were emitted during the window defined by {@code time}
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays the items that were emitted during the window defined by {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5989,8 +5969,8 @@ public final ConnectableObservable replay(long time, TimeUnit unit) {
     }
 
     /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source
-     * Observable and replays all items emitted by that Observable within a specified time window.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * replays all items emitted by that Observable within a specified time window.
      * 
    
      * 
      * 
@@ -5999,9 +5979,9 @@ public final ConnectableObservable replay(long time, TimeUnit unit) {
      * @param unit
      *            the time unit of {@code time}
      * @param scheduler
-     *            the scheduler that is the time source for the window
-     * @return a {@link ConnectableObservable} that shares a single subscription to the underlying
-     *         Observable and replays the items that were emitted during the window defined by {@code time}
+     *            the Scheduler that is the time source for the window
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     *         replays the items that were emitted during the window defined by {@code time}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -6010,15 +5990,17 @@ public final ConnectableObservable replay(long time, TimeUnit unit, Scheduler
     }
 
     /**
-     * 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} on the given {@link Scheduler}.
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that
+     * will replay all of its items and notifications to any future {@link Observer} on the given
+     * {@link Scheduler}.
      * 
    
      * 
      * 
      * @param scheduler
-     *            the scheduler on which the Observers will observe the emitted items
-     * @return a {@link ConnectableObservable} that shares a single subscription to the source
-     *         Observable that will replay all of its items and notifications to any future {@link Observer} on the given {@link Scheduler}
+     *            the Scheduler on which the Observers will observe the emitted items
+     * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable that
+     *         will replay all of its items and notifications to any future {@link Observer} on the given
+     *         {@link Scheduler}
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -6027,17 +6009,18 @@ public final ConnectableObservable replay(Scheduler scheduler) {
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} (infinite retry count).
+     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError}
+     * (infinite retry count).
      * 
    
      * 
      * 
    
-     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the
-     * source Observable.
+     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source
+     * Observable rather than propagating the {@code onError} call.
      * 
    
-     * Any and all items emitted by the source Observable will be emitted by the resulting
-     * Observable, even those emitted during failed subscriptions. For example, if an Observable
-     * fails at first but emits {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence of emissions and notifications would be
-     * {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
+     * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even
+     * those emitted during failed subscriptions. For example, if an Observable fails at first but emits
+     * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence
+     * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
      * 
      * @return the source Observable modified with retry logic
      * @see RxJava Wiki: retry()
@@ -6047,17 +6030,19 @@ public final Observable retry() {
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} up to a certain number of retries.
+     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError}
+     * up to a specified number of retries.
      * 
    
      * 
      * 
    
-     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the
-     * source Observable for a maximum of {@code retryCount} resubscriptions.
+     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source
+     * Observable for a maximum of {@code retryCount} resubscriptions rather than propagating the
+     * {@code onError} call.
      * 
    
-     * Any and all items emitted by the source Observable will be emitted by the resulting
-     * Observable, even those emitted during failed subscriptions. For example, if an Observable
-     * fails at first but emits {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence of emissions and notifications would be
-     * {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
+     * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even
+     * those emitted during failed subscriptions. For example, if an Observable fails at first but emits
+     * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence
+     * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
      * 
      * @param retryCount
      *            number of retry attempts before failing
@@ -6069,8 +6054,8 @@ public final Observable retry(int retryCount) {
     }
 
     /**
-     * Returns an Observable that emits the results of sampling the items emitted by the source
-     * Observable at a specified time interval.
+     * Returns an Observable that emits the results of sampling the items emitted by the source Observable at a
+     * specified time interval.
      * 
    
      * 
      * 
@@ -6078,8 +6063,8 @@ public final Observable retry(int retryCount) {
      *            the sampling rate
      * @param unit
      *            the {@link TimeUnit} in which {@code period} is defined
-     * @return an Observable that emits the results of sampling the items emitted by the source
-     *         Observable at the specified time interval
+     * @return an Observable that emits the results of sampling the items emitted by the source Observable at
+     *         the specified time interval
      * @see RxJava Wiki: sample()
      */
     public final Observable sample(long period, TimeUnit unit) {
@@ -6087,8 +6072,8 @@ public final Observable sample(long period, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits the results of sampling the items emitted by the source
-     * Observable at a specified time interval.
+     * Returns an Observable that emits the results of sampling the items emitted by the source Observable at a
+     * specified time interval.
      * 
    
      * 
      * 
@@ -6098,8 +6083,8 @@ public final Observable sample(long period, TimeUnit unit) {
      *            the {@link TimeUnit} in which {@code 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
+     * @return an Observable that emits the results of sampling the items emitted by the source Observable at
+     *         the specified time interval
      * @see RxJava Wiki: sample()
      */
     public final Observable sample(long period, TimeUnit unit, Scheduler scheduler) {
@@ -6107,15 +6092,15 @@ public final Observable sample(long period, TimeUnit unit, Scheduler schedule
     }
 
     /**
-     * Return an Observable that emits the results of sampling the items emitted by the source
-     * Observable whenever the specified {@code sampler} Observable emits an item or completes.
+     * Return an Observable that emits the results of sampling the items emitted by the source Observable
+     * whenever the specified {@code sampler} Observable emits an item or completes.
      * 
    
      * 
      * 
      * @param sampler
      *            the Observable to use for sampling the source Observable
-     * @return an Observable that emits the results of sampling the items emitted by this Observable
-     *         whenever the {@code sampler} Observable emits an item or completes
+     * @return an Observable that emits the results of sampling the items emitted by this Observable whenever
+     *         the {@code sampler} Observable emits an item or completes
      * @see RxJava Wiki: sample()
      */
     public final  Observable sample(Observable sampler) {
@@ -6123,18 +6108,19 @@ public final  Observable sample(Observable sampler) {
     }
 
     /**
-     * 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, emitting the result of each of these iterations.
+     * 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,
+     * emitting the result of each of these iterations.
      * 
    
      * 
      * 
    
      * This sort of function is sometimes called an accumulator.
      * 
      * @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
+     *            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 RxJava Wiki: scan()
      * @see MSDN: Observable.Scan
@@ -6144,25 +6130,26 @@ public final Observable scan(Func2 accumulator) {
     }
 
     /**
-     * Returns an Observable that applies a function of your choosing to the first item emitted by a
-     * source Observable and a seed value, 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, emitting the result of each of these
-     * iterations.
+     * Returns an Observable that applies a function of your choosing to the first item emitted by a source
+     * Observable and a seed value, 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, emitting the result of each of these iterations.
      * 
    
      * 
      * 
    
      * This sort of function is sometimes called an accumulator.
      * 
    
-     * Note that the Observable that results from this method will emit {@code initialValue} as its
-     * first emitted item.
+     * Note that the Observable that results from this method will emit {@code initialValue} as its first
+     * emitted item.
      * 
      * @param initialValue
      *            the initial (seed) accumulator 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
+     *            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 {@code initialValue} followed by the results of each call to the
+     *         accumulator function
      * @see RxJava Wiki: scan()
      * @see MSDN: Observable.Scan
      */
@@ -6171,9 +6158,9 @@ public final  Observable scan(R initialValue, Func2 accum
     }
 
     /**
-     * If the source Observable completes after emitting a single item, return an Observable
-     * that emits that item. If the source Observable emits more than one item or no items, throw
-     * an {@code IllegalArgumentException}.
+     * If the source Observable completes after emitting a single item, return an Observable that emits that
+     * item. If the source Observable emits more than one item or no items, throw an
+     * {@code IllegalArgumentException}.
      * 
    
      * 
      * 
@@ -6188,19 +6175,19 @@ public final Observable single() {
     }
 
     /**
-     * If the Observable completes after emitting a single item that matches a specified predicate,
-     * return an Observable that emits that item. If the source Observable emits more than one such
-     * item or no such items, throw an {@code IllegalArgumentException}.
+     * If the Observable completes after emitting a single item that matches a specified predicate, return an
+     * Observable that emits that item. If the source Observable emits more than one such item or no such items,
+     * throw an {@code IllegalArgumentException}.
      * 
    
      * 
      * 
      * @param predicate
      *            a predicate function to evaluate items emitted by the source Observable
-     * @return an Observable that emits the single item emitted by the source Observable that
-     *         matches the predicate
+     * @return an Observable that emits the single item emitted by the source Observable that matches the
+     *         predicate
      * @throws IllegalArgumentException
-     *             if the source Observable emits either more than one item that matches the
-     *             predicate or no items that match the predicate
+     *             if the source Observable emits either more than one item that matches the predicate or no
+     *             items that match the predicate
      * @see RxJava Wiki: single()
      * @see MSDN: {@code Observable.singleAsync()}
      */
@@ -6209,15 +6196,16 @@ public final Observable single(Func1 predicate) {
     }
 
     /**
-     * If the source Observable completes after emitting a single item, return an Observable that
-     * emits that item; if the source Observable is empty, return an Observable that emits a default
-     * item. If the source Observable emits more than one item, throw an {@code IllegalArgumentException.} 
    
+     * If the source Observable completes after emitting a single item, return an Observable that emits that
+     * item; if the source Observable is empty, return an Observable that emits a default item. If the source
+     * Observable emits more than one item, throw an {@code IllegalArgumentException.}
+     * 
    
      * 
      * 
      * @param defaultValue
      *            a default value to emit if the source Observable emits no item
-     * @return an Observable that emits the single item emitted by the source Observable, or a
-     *         default item if the source Observable is empty
+     * @return an Observable that emits the single item emitted by the source Observable, or a default item if
+     *         the source Observable is empty
      * @throws IllegalArgumentException
      *             if the source Observable emits more than one item
      * @see RxJava Wiki: single()
@@ -6228,10 +6216,10 @@ public final Observable singleOrDefault(T defaultValue) {
     }
 
     /**
-     * If the Observable completes after emitting a single item that matches a predicate, return an
-     * Observable that emits that item; if the source Observable emits no such item, return an
-     * Observable that emits a default item. If the source Observable emits more than one such item,
-     * throw an {@code IllegalArgumentException}.
+     * If the Observable completes after emitting a single item that matches a predicate, return an Observable
+     * that emits that item; if the source Observable emits no such item, return an Observable that emits a
+     * default item. If the source Observable emits more than one such item, throw an
+     * {@code IllegalArgumentException}.
      * 
    
      * 
      * 
@@ -6239,8 +6227,8 @@ public final Observable singleOrDefault(T defaultValue) {
      *            a default item to emit if the source Observable emits no matching items
      * @param predicate
      *            a predicate function to evaluate items emitted by the source Observable
-     * @return an Observable that emits the single item emitted by the source Observable that
-     *         matches the predicate, or the default item if no emitted item matches the predicate
+     * @return an Observable that emits the single item emitted by the source Observable that matches the
+     *         predicate, or the default item if no emitted item matches the predicate
      * @throws IllegalArgumentException
      *             if the source Observable emits more than one item that matches the predicate
      * @see RxJava Wiki: single()
@@ -6251,15 +6239,15 @@ public final Observable singleOrDefault(T defaultValue, Func1
      * 
      * 
      * @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 {@code num} items that the source Observable emits
+     * @return an Observable that is identical to the source Observable except that it does not emit the first
+     *         {@code num} items that the source Observable emits
      * @see RxJava Wiki: skip()
      */
     public final Observable skip(int num) {
@@ -6267,8 +6255,8 @@ public final Observable skip(int num) {
     }
 
     /**
-     * Returns an Observable that skips values emitted by the source Observable before a specified
-     * time window elapses.
+     * Returns an Observable that skips values emitted by the source Observable before a specified time window
+     * elapses.
      * 
    
      * 
      * 
@@ -6276,8 +6264,8 @@ public final Observable skip(int num) {
      *            the length of the time window to skip
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that skips values emitted by the source Observable before the time
-     *         window defined by {@code time} elapses
+     * @return an Observable that skips values emitted by the source Observable before the time window defined
+     *         by {@code time} elapses and the emits the remainder
      * @see RxJava Wiki: skip()
      */
     public final Observable skip(long time, TimeUnit unit) {
@@ -6285,8 +6273,8 @@ public final Observable skip(long time, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that skips values emitted by the source Observable before a specified
-     * time window on a specified {@link Scheduler} elapses.
+     * Returns an Observable that skips values emitted by the source Observable before a specified time window
+     * on a specified {@link Scheduler} elapses.
      * 
    
      * 
      * 
@@ -6296,8 +6284,8 @@ public final Observable skip(long time, TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the {@link Scheduler} on which the timed wait happens
-     * @return an Observable that skips values emitted by the source Observable before the time
-     *         window defined by {@code time} and {@code scheduler} elapses
+     * @return an Observable that skips values emitted by the source Observable before the time window defined
+     *         by {@code time} and {@code scheduler} elapses, and then emits the remainder
      * @see RxJava Wiki: skip()
      */
     public final Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
@@ -6305,19 +6293,19 @@ public final Observable skip(long time, TimeUnit unit, Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that drops a specified number of items from the end of the sequence
-     * emitted by the source Observable.
+     * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
+     * source Observable.
      * 
    
      * 
      * 
    
-     * This Observer accumulates a queue long enough to store the first {@code count} items. As more
-     * items are received, items are taken from the front of the queue and emitted by the returned
-     * Observable. This causes such items to be delayed.
+     * This Observer accumulates a queue long enough to store the first {@code count} items. As more items are
+     * received, items are taken from the front of the queue and emitted by the returned Observable. This causes
+     * such items to be delayed.
      * 
      * @param count
      *            number of items to drop from the end of the source sequence
-     * @return an Observable that emits the items emitted by the source Observable except for the
-     *         dropped ones at the end
+     * @return an Observable that emits the items emitted by the source Observable except for the dropped ones
+     *         at the end
      * @throws IndexOutOfBoundsException
      *             if {@code count} is less than zero
      * @see RxJava Wiki: skipLast()
@@ -6328,8 +6316,8 @@ public final Observable skipLast(int count) {
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source Observable during a specified
-     * time window before the source completes.
+     * Returns an Observable that drops items emitted by the source Observable during a specified time window
+     * before the source completes.
      * 
    
      * 
      * 
@@ -6337,8 +6325,8 @@ public final Observable skipLast(int count) {
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that drops those items emitted by the source Observable in a time
-     *         window before the source completes defined by {@code time}
+     * @return an Observable that drops those items emitted by the source Observable in a time window before the
+     *         source completes defined by {@code time}
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
@@ -6347,8 +6335,8 @@ public final Observable skipLast(long time, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that drops items emitted by the source Observable during a specified
-     * time window (defined on a specified scheduler) before the source completes.
+     * Returns an Observable that drops items emitted by the source Observable during a specified time window
+     * (defined on a specified scheduler) before the source completes.
      * 
    
      * 
      * 
@@ -6358,8 +6346,8 @@ public final Observable skipLast(long time, TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the scheduler used as the time source
-     * @return an Observable that drops those items emitted by the source Observable in a time
-     *         window before the source completes defined by {@code time} and {@code scheduler}
+     * @return an Observable that drops those items emitted by the source Observable in a time window before the
+     *         source completes defined by {@code time} and {@code scheduler}
      * @see RxJava Wiki: skipLast()
      * @see MSDN: Observable.SkipLast
      */
@@ -6368,16 +6356,16 @@ public final Observable skipLast(long time, TimeUnit unit, Scheduler schedule
     }
 
     /**
-     * Returns an Observable that skips items emitted by the source Observable until a second
-     * Observable emits an item.
+     * Returns an Observable that skips items emitted by the source Observable until a second Observable emits
+     * an item.
      * 
    
      * 
      * 
      * @param other
-     *            the second Observable that has to emit an item before the source Observable's
-     *            elements begin to be mirrored by the resulting Observable
-     * @return an Observable that skips items from the source Observable until the second
-     *         Observable emits an item, then emits the remaining items
+     *            the second Observable that has to emit an item before the source Observable's elements begin
+     *            to be mirrored by the resulting Observable
+     * @return an Observable that skips items from the source Observable until the second Observable emits an
+     *         item, then emits the remaining items
      * @see RxJava Wiki: skipUntil()
      * @see MSDN: Observable.SkipUntil
      */
@@ -6386,16 +6374,15 @@ public final  Observable skipUntil(Observable other) {
     }
 
     /**
-     * Returns an Observable that skips all items emitted by the source Observable as long as a
-     * specified condition holds true, but emits all further source items as soon as the condition
-     * becomes false.
+     * Returns an Observable that skips all items emitted by the source Observable as long as a specified
+     * condition holds true, but 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
-     * @return an Observable that begins emitting items emitted by the source Observable when the
-     *         specified predicate becomes false
+     * @return an Observable that begins emitting items emitted by the source Observable when the specified
+     *         predicate becomes false
      * @see RxJava Wiki: skipWhile()
      * @see MSDN: Observable.SkipWhile
      */
@@ -6404,18 +6391,16 @@ public final Observable skipWhile(Func1 predicate) {
     }
 
     /**
-     * Returns an Observable that skips all items emitted by the source Observable as long as a
-     * specified condition holds true, but emits all further source items as soon as the condition
-     * becomes false.
+     * Returns an Observable that skips all items emitted by the source Observable as long as a specified
+     * condition holds true, but 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. It takes the
-     *            emitted item as the first parameter and the sequential index of the emitted item
-     *            as a second parameter.
-     * @return an Observable that begins emitting items emitted by the source Observable when the
-     *         specified predicate becomes false
+     *            a function to test each item emitted from the source Observable. It takes the emitted item as
+     *            the first parameter and the sequential index of the emitted item as a second parameter.
+     * @return an Observable that begins emitting items emitted by the source Observable when the specified
+     *         predicate becomes false
      * @see RxJava Wiki: skipWhileWithIndex()
      * @see MSDN: Observable.SkipWhile
      */
@@ -6424,15 +6409,15 @@ public final Observable skipWhileWithIndex(Func2
     }
 
     /**
-     * Returns an Observable that emits the items in a specified {@link Iterable} before it begins
-     * to emit items emitted by the source Observable.
+     * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items
+     * emitted by the source Observable.
      * 
    
      * 
      * 
      * @param values
      *            an Iterable that contains the items you want the modified Observable to emit first
-     * @return an Observable that emits the items in the specified {@link Iterable} and then emits
-     *         the items emitted by the source Observable
+     * @return an Observable that emits the items in the specified {@link Iterable} and then emits the items
+     *         emitted by the source Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(Iterable values) {
@@ -6440,16 +6425,17 @@ public final Observable startWith(Iterable values) {
     }
 
     /**
-     * Returns an Observable that emits the items in a specified {@link Iterable}, on a specified {@link Scheduler} before it begins to emit items emitted by the source Observable.
+     * Returns an Observable that emits the items in a specified {@link Iterable}, on a specified
+     * {@link Scheduler}, before it begins to emit items emitted by the source Observable.
      * 
    
      * 
      * 
      * @param values
      *            an Iterable that contains the items you want the modified Observable to emit first
      * @param scheduler
-     *            the scheduler to emit the prepended values on
-     * @return an Observable that emits the items in the specified {@link Iterable} and then emits
-     *         the items emitted by the source Observable
+     *            the Scheduler to emit the prepended values on
+     * @return an Observable that emits the items in the specified {@link Iterable} and then emits the items
+     *         emitted by the source Observable
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
      */
@@ -6458,15 +6444,15 @@ public final Observable startWith(Iterable values, Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that emits a specified item before it begins to emit items emitted by
-     * the source Observable.
+     * Returns an Observable that emits a specified item before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
      * @param t1
      *            the item to emit
-     * @return an Observable that emits the specified item before it begins to emit items emitted by
-     *         the source Observable
+     * @return an Observable that emits the specified item before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1) {
@@ -6474,8 +6460,8 @@ public final Observable startWith(T t1) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6483,8 +6469,8 @@ public final Observable startWith(T t1) {
      *            the first item to emit
      * @param t2
      *            the second item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2) {
@@ -6492,8 +6478,8 @@ public final Observable startWith(T t1, T t2) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6503,8 +6489,8 @@ public final Observable startWith(T t1, T t2) {
      *            the second item to emit
      * @param t3
      *            the third item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3) {
@@ -6512,8 +6498,8 @@ public final Observable startWith(T t1, T t2, T t3) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6525,8 +6511,8 @@ public final Observable startWith(T t1, T t2, T t3) {
      *            the third item to emit
      * @param t4
      *            the fourth item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3, T t4) {
@@ -6534,8 +6520,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6549,8 +6535,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4) {
      *            the fourth item to emit
      * @param t5
      *            the fifth item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3, T t4, T t5) {
@@ -6558,8 +6544,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6584,8 +6570,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6603,8 +6589,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
      *            the sixth item to emit
      * @param t7
      *            the seventh item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
@@ -6612,8 +6598,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6633,8 +6619,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      *            the seventh item to emit
      * @param t8
      *            the eighth item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
@@ -6642,8 +6628,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     }
 
     /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted
-     * by the source Observable.
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
      * 
    
      * 
      * 
@@ -6665,8 +6651,8 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *            the eighth item to emit
      * @param t9
      *            the ninth item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
+     * @return an Observable that emits the specified items before it begins to emit items emitted by the source
+     *         Observable
      * @see RxJava Wiki: startWith()
      */
     public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) {
@@ -6674,17 +6660,17 @@ public final Observable startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     }
 
     /**
-     * Returns an Observable that emits the items from a specified array, on a specified scheduler,
-     * before it begins to emit items emitted by the source Observable.
+     * Returns an Observable that emits the items from a specified array, on a specified Scheduler, before it
+     * begins to emit items emitted by the source Observable.
      * 
    
      * 
      * 
      * @param values
      *            the items you want the modified Observable to emit first
      * @param scheduler
-     *            the scheduler to emit the prepended values on
-     * @return an Observable that emits the items from {@code values}, on {@code scheduler}, before
-     *         it begins to emit items emitted by the source Observable.
+     *            the Scheduler to emit the prepended values on
+     * @return an Observable that emits the items from {@code values}, on {@code scheduler}, before it begins to
+     *         emit items emitted by the source Observable.
      * @see RxJava Wiki: startWith()
      * @see MSDN: Observable.StartWith
      */
@@ -6695,8 +6681,10 @@ public final Observable startWith(T[] values, Scheduler scheduler) {
     /**
      * Subscribe and ignore all events.
      * 
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
+     * @throws OnErrorNotImplementedException
+     *             if the Observable tries to call {@code onError}
      */
     public final Subscription subscribe() {
         return protectivelyWrapAndSubscribe(new Subscriber() {
@@ -6725,8 +6713,12 @@ public final void onNext(T args) {
      * 
      * @param onNext
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws OnErrorNotImplementedException
+     *             if the Observable tries to call {@code onError}
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public final Subscription subscribe(final Action1 onNext) {
@@ -6737,7 +6729,8 @@ public final Subscription subscribe(final Action1 onNext) {
         /**
          * 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 Observer"
+         * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to
+         * user code from within an Observer"
          */
         return protectivelyWrapAndSubscribe(new Subscriber() {
 
@@ -6760,16 +6753,20 @@ public final void onNext(T args) {
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
      * 
      * @param onNext
      *            FIXME FIXME FIXME
      * @param onError
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
      * @see RxJava Wiki: onNext, onCompleted, and onError
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
      */
     public final Subscription subscribe(final Action1 onNext, final Action1 onError) {
         if (onNext == null) {
@@ -6806,8 +6803,8 @@ public final void onNext(T args) {
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
      * 
      * @param onNext
      *            FIXME FIXME FIXME
@@ -6815,8 +6812,14 @@ public final void onNext(T args) {
      *            FIXME FIXME FIXME
      * @param onComplete
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     * @throws IllegalArgumentException
+     *             if {@code onComplete} is null
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete) {
@@ -6856,8 +6859,8 @@ public final void onNext(T args) {
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
      * 
      * @param onNext
      *            FIXME FIXME FIXME
@@ -6867,8 +6870,8 @@ public final void onNext(T args) {
      *            FIXME FIXME FIXME
      * @param scheduler
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onComplete, Scheduler scheduler) {
@@ -6876,8 +6879,8 @@ public final Subscription subscribe(final Action1 onNext, final Actio
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
      * 
      * @param onNext
      *            FIXME FIXME FIXME
@@ -6885,8 +6888,8 @@ public final Subscription subscribe(final Action1 onNext, final Actio
      *            FIXME FIXME FIXME
      * @param scheduler
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public final Subscription subscribe(final Action1 onNext, final Action1 onError, Scheduler scheduler) {
@@ -6894,25 +6897,47 @@ public final Subscription subscribe(final Action1 onNext, final Actio
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
      * 
      * @param onNext
      *            FIXME FIXME FIXME
      * @param scheduler
      *            FIXME FIXME FIXME
-     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving
-     *         items before the Observable has finished sending them
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
      * @see RxJava Wiki: onNext, onCompleted, and onError
      */
     public final Subscription subscribe(final Action1 onNext, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext);
     }
 
+    /**
+     * An {@link Observer} must subscribe to an Observable in order to receive items and notifications from the
+     * Observable.
+     *
+     * @param observer
+     *            FIXME FIXME FIXME
+     * @param scheduler
+     *            FIXME FIXME FIXME
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
     public final Subscription subscribe(final Observer observer, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(observer);
     }
-    
+
+    /**
+     * An {@link Observer} must subscribe to an Observable in order to receive items and notifications from the
+     * Observable.
+     *
+     * @param observer
+     *            FIXME FIXME FIXME
+     * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
+     *         the Observable has finished sending them
+     * @see RxJava Wiki: onNext, onCompleted, and onError
+     */
     public final Subscription subscribe(final Observer observer) {
         return subscribe(new Subscriber() {
 
@@ -6935,29 +6960,31 @@ public void onNext(T t) {
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * A {@link Subscriber} 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:
      * 
      
-     * 
    1. It stores a reference to the Observer in a collection object, such as a {@code List} object.
      2. 
-     * 
    2. 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.
      3. 
+     * 
    3. It stores a reference to the Subscriber in a collection object, such as a {@code List}
+     * object.
      4. 
+     * 
    4. 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.
      5. 
      * 
    
-     * 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.
+     * An {@code Observable} instance is responsible for accepting all subscriptions and notifying all
+     * Subscribers. Unless the documentation for a particular {@code Observable} implementation indicates
+     * otherwise, Subscriber should make no assumptions about the order in which multiple Subscribers will
+     * receive their notifications.
      * 
    
      * For more information see the
      * RxJava Wiki
      * 
      * @param observer
-     *            the {@link 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}
+     *            the {@link Subscriber}
+     * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can 
+     *         unsubscribe from the Observable
+     * @throws IllegalStateException
+     *             if the {@link Subscriber} provided as the argument to {@code subscribe()} is {@code null}
      */
     public final Subscription subscribe(Subscriber observer) {
         // allow the hook to intercept and/or decorate
@@ -6968,11 +6995,15 @@ public final Subscription subscribe(Subscriber observer) {
         }
         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
+            /*
+             * 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 Observer"
+            /*
+             * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
+             * to user code from within an Observer"
              */
             if (isInternalImplementation(observer)) {
                 onSubscribeFunction.call(observer);
@@ -7012,29 +7043,31 @@ public void call() {
     }
 
     /**
-     * An {@link Observer} must call an Observable's {@code subscribe} method in order to receive
-     * items and notifications from the Observable.
+     * A {@link Subscriber} 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:
      * 
      
-     * 
    1. It stores a reference to the Observer in a collection object, such as a {@code List} object.
      2. 
-     * 
    2. 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.
      3. 
+     * 
    3. It stores a reference to the Subscriber in a collection object, such as a {@code List}
+     * object.
      4. 
+     * 
    4. 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.
      5. 
      * 
    
-     * 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.
+     * An {@code Observable} instance is responsible for accepting all subscriptions and notifying all
+     * Subscribers. Unless the documentation for a particular {@code Observable} implementation indicates
+     * otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
+     * receive their notifications.
      * 
    
      * For more information see the
      * RxJava Wiki
      * 
      * @param observer
-     *            the {@link Observer}
+     *            the {@link Subscriber}
      * @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
+     *            the {@link Scheduler} on which Subscribers subscribe to the Observable
+     * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can
+     *         unsubscribe from the Observable
      * @throws IllegalArgumentException
      *             if an argument to {@code subscribe()} is {@code null}
      */
@@ -7043,14 +7076,15 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
     }
 
     /**
-     * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified {@link Scheduler}.
+     * Asynchronously subscribes and unsubscribes Observers to this Observable 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}
+     * @return the source Observable modified so that its subscriptions and unsubscriptions happen on the
+     *         specified {@link Scheduler}
      * @see RxJava Wiki: subscribeOn()
      */
     public final Observable subscribeOn(Scheduler scheduler) {
@@ -7058,15 +7092,15 @@ public final Observable subscribeOn(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that extracts a Double from each of the items emitted by the source
-     * Observable via a function you specify, and then emits the sum of these Doubles.
+     * Returns an Observable that extracts a Double from each of the items emitted by the source Observable via
+     * a function you specify, and then emits the sum of these Doubles.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to extract a Double from each item emitted by the source Observable
-     * @return an Observable that emits the Double sum of the Double values corresponding to the
-     *         items emitted by the source Observable as transformed by the provided function
+     * @return an Observable that emits the Double sum of the Double values corresponding to the items emitted
+     *         by the source Observable as transformed by the provided function
      * @see RxJava Wiki: sumDouble()
      * @see MSDN: Observable.Sum
      */
@@ -7075,15 +7109,15 @@ public final Observable sumDouble(Func1 valueExtracto
     }
 
     /**
-     * Returns an Observable that extracts a Float from each of the items emitted by the source
-     * Observable via a function you specify, and then emits the sum of these Floats.
+     * Returns an Observable that extracts a Float from each of the items emitted by the source Observable via
+     * a function you specify, and then emits the sum of these Floats.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to extract a Float from each item emitted by the source Observable
-     * @return an Observable that emits the Float sum of the Float values corresponding to the items
-     *         emitted by the source Observable as transformed by the provided function
+     * @return an Observable that emits the Float sum of the Float values corresponding to the items emitted by
+     *         the source Observable as transformed by the provided function
      * @see RxJava Wiki: sumFloat()
      * @see MSDN: Observable.Sum
      */
@@ -7092,15 +7126,15 @@ public final Observable sumFloat(Func1 valueExtractor)
     }
 
     /**
-     * Returns an Observable that extracts an Integer from each of the items emitted by the source
-     * Observable via a function you specify, and then emits the sum of these Integers.
+     * Returns an Observable that extracts an Integer from each of the items emitted by the source Observable
+     * via a function you specify, and then emits the sum of these Integers.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to extract an Integer from each item emitted by the source Observable
-     * @return an Observable that emits the Integer sum of the Integer values corresponding to the
-     *         items emitted by the source Observable as transformed by the provided function
+     * @return an Observable that emits the Integer sum of the Integer values corresponding to the items emitted
+     *         by the source Observable as transformed by the provided function
      * @see RxJava Wiki: sumInteger()
      * @see MSDN: Observable.Sum
      */
@@ -7109,15 +7143,15 @@ public final Observable sumInteger(Func1 valueExtra
     }
 
     /**
-     * Returns an Observable that extracts a Long from each of the items emitted by the source
-     * Observable via a function you specify, and then emits the sum of these Longs.
+     * Returns an Observable that extracts a Long from each of the items emitted by the source Observable via a
+     * function you specify, and then emits the sum of these Longs.
      * 
    
      * 
      * 
      * @param valueExtractor
      *            the function to extract a Long from each item emitted by the source Observable
-     * @return an Observable that emits the Long sum of the Long values corresponding to the items
-     *         emitted by the source Observable as transformed by the provided function
+     * @return an Observable that emits the Long sum of the Long values corresponding to the items emitted by
+     *         the source Observable as transformed by the provided function
      * @see RxJava Wiki: sumLong()
      * @see MSDN: Observable.Sum
      */
@@ -7126,34 +7160,37 @@ public final Observable sumLong(Func1 valueExtractor) {
     }
 
     /**
-     * Returns a new Observable by applying a function that you supply to each item emitted by the
-     * source Observable that returns an Observable, and then emitting the items emitted by the
-     * most recently emitted of these Observables.
+     * Returns a new Observable by applying a function that you supply to each item emitted by the source
+     * Observable that returns an Observable, and then emitting the items emitted by the most recently emitted
+     * of these Observables.
      * 
    
      * 
      * 
      * @param func
-     *            a function that, when applied to an item emitted by the source Observable, returns
-     *            an Observable
-     * @return an Observable that emits the items emitted by the Observable returned from applying {@code func} to the most recently emitted item emitted by the source Observable
+     *            a function that, when applied to an item emitted by the source Observable, returns an
+     *            Observable
+     * @return an Observable that emits the items emitted by the Observable returned from applying {@code func}
+     *         to the most recently emitted item emitted by the source Observable
      */
     public final  Observable switchMap(Func1> func) {
         return switchOnNext(map(func));
     }
 
     /**
-     * Wraps the source Observable in another Observable that ensures that the resulting Observable
-     * is chronologically well-behaved.
+     * Wraps the source Observable 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 either {@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.
+     * 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 either {@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.
      * 
-     * @return an Observable that is a chronologically well-behaved version of the source
-     *         Observable, and that synchronously notifies its {@link Observer}s
+     * @return an Observable that is a chronologically well-behaved version of the source Observable, and that
+     *         synchronously notifies its {@link Observer}s
      * @see RxJava Wiki: synchronize()
      */
     public final Observable synchronize() {
@@ -7161,21 +7198,23 @@ public final Observable synchronize() {
     }
 
     /**
-     * Wraps the source Observable in another Observable that ensures that the resulting Observable
-     * is chronologically well-behaved by acquiring a mutual-exclusion lock for the object provided
-     * as the {@code lock} parameter.
+     * Wraps the source Observable in another Observable that ensures that the resulting Observable is
+     * chronologically well-behaved by acquiring a mutual-exclusion lock for the object provided as the
+     * {@code lock} parameter.
      * 
    
      * 
      * 
    
-     * 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 either {@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.
+     * 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 either {@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 lock
      *            the lock object to synchronize each observer call on
-     * @return an Observable that is a chronologically well-behaved version of the source
-     *         Observable, and that synchronously notifies its {@link Observer}s
+     * @return an Observable that is a chronologically well-behaved version of the source Observable, and that
+     *         synchronously notifies its {@link Observer}s
      * @see RxJava Wiki: synchronize()
      */
     public final Observable synchronize(Object lock) {
@@ -7183,19 +7222,18 @@ public final Observable synchronize(Object lock) {
     }
 
     /**
-     * Returns an Observable that emits only the first {@code num} items emitted by the source
-     * Observable.
+     * Returns an Observable that emits only the first {@code 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 {@code num} times before invoking
+     * This method returns an Observable that will invoke a subscribing {@link Observer}'s
+     * {@link Observer#onNext onNext} function a maximum of {@code num} times before invoking
      * {@link Observer#onCompleted onCompleted}.
      * 
      * @param num
      *            the maximum number of items to emit
-     * @return an Observable that emits only the first {@code num} items emitted by the source
-     *         Observable, or all of the items from the source Observable if that Observable emits
-     *         fewer than {@code num} items
+     * @return an Observable that emits only the first {@code num} items emitted by the source Observable, or
+     *         all of the items from the source Observable if that Observable emits fewer than {@code num} items
      * @see RxJava Wiki: take()
      */
     public final Observable take(final int num) {
@@ -7203,8 +7241,8 @@ public final Observable take(final int num) {
     }
 
     /**
-     * Returns an Observable that emits those items emitted by source Observable before a specified
-     * time runs out.
+     * Returns an Observable that emits those items emitted by source Observable before a specified time runs
+     * out.
      * 
    
      * 
      * 
@@ -7212,8 +7250,7 @@ public final Observable take(final int num) {
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits those items emitted by the source Observable before the time
-     *         runs out
+     * @return an Observable that emits those items emitted by the source Observable before the time runs out
      * @see RxJava Wiki: take()
      */
     public final Observable take(long time, TimeUnit unit) {
@@ -7221,8 +7258,8 @@ public final Observable take(long time, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits those items emitted by source Observable before a specified
-     * time (on a specified scheduler) runs out.
+     * Returns an Observable that emits those items emitted by source Observable before a specified time (on a
+     * specified Scheduler) runs out.
      * 
    
      * 
      * 
@@ -7231,9 +7268,9 @@ public final Observable take(long time, TimeUnit unit) {
      * @param unit
      *            the time unit of {@code time}
      * @param scheduler
-     *            the scheduler used for time source
-     * @return an Observable that emits those items emitted by the source Observable before the time
-     *         runs out, according to the specified scheduler
+     *            the Scheduler used for time source
+     * @return an Observable that emits those items emitted by the source Observable before the time runs out,
+     *         according to the specified Scheduler
      * @see RxJava Wiki: take()
      */
     public final Observable take(long time, TimeUnit unit, Scheduler scheduler) {
@@ -7245,9 +7282,8 @@ public final Observable take(long time, TimeUnit unit, Scheduler scheduler) {
      * 
    
      * 
      * 
-     * @return an Observable that emits only the very first item emitted by the source Observable,
-     *         or an empty Observable if the source Observable completes without emitting a single
-     *         item
+     * @return an Observable that emits only the very first item emitted by the source Observable, or an empty
+     *         Observable if the source Observable completes without emitting a single item
      * @see RxJava Wiki: first()
      * @see MSDN: {@code Observable.firstAsync()}
      * @deprecated use {@code take(1)} directly
@@ -7258,16 +7294,16 @@ public final Observable takeFirst() {
     }
 
     /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable
-     * that satisfies a specified condition.
+     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
+     * a specified condition.
      * 
    
      * 
      * 
      * @param predicate
      *            the condition any item emitted by the source Observable has to satisfy
-     * @return an Observable that emits only the very first item emitted by the source Observable
-     *         that satisfies the given condition, or that completes without emitting anything if
-     *         the source Observable completes without emitting a single condition-satisfying item
+     * @return an Observable that emits only the very first item emitted by the source Observable that satisfies
+     *         the given condition, or that completes without emitting anything if the source Observable
+     *         completes without emitting a single condition-satisfying item
      * @see RxJava Wiki: first()
      * @see MSDN: {@code Observable.firstAsync()}
      */
@@ -7276,16 +7312,14 @@ public final Observable takeFirst(Func1 predicate) {
     }
 
     /**
-     * Returns an Observable that emits only the last {@code count} items emitted by the source
-     * Observable.
+     * Returns an Observable that emits only the last {@code count} items emitted by the source Observable.
      * 
    
      * 
      * 
      * @param count
-     *            the number of items to emit from the end of the sequence of items emitted by the
-     *            source Observable
-     * @return an Observable that emits only the last {@code count} items emitted by the source
-     *         Observable
+     *            the number of items to emit from the end of the sequence of items emitted by the source
+     *            Observable
+     * @return an Observable that emits only the last {@code count} items emitted by the source Observable
      * @see RxJava Wiki: takeLast()
      */
     public final Observable takeLast(final int count) {
@@ -7293,8 +7327,8 @@ public final Observable takeLast(final int count) {
     }
 
     /**
-     * Return an Observable that emits at most a specified number of items from the source
-     * Observable that were emitted in a specified window of time before the Observable completed.
+     * Return an Observable that emits at most a specified number of items from the source Observable that were
+     * emitted in a specified window of time before the Observable completed.
      * 
    
      * 
      * 
@@ -7304,17 +7338,17 @@ public final Observable takeLast(final int count) {
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits at most {@code count} items from the source Observable that
-     *         were emitted in a specified window of time before the Observable completed.
+     * @return an Observable that emits at most {@code count} items from the source Observable that were emitted
+     *         in a specified window of time before the Observable completed
      */
     public final Observable takeLast(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit, Schedulers.computation());
     }
 
     /**
-     * Return an Observable that emits at most a specified number of items from the source
-     * Observable that were emitted in a specified window of time before the Observable
-     * completed, where the timing information is provided by a given scheduler.
+     * Return an Observable that emits at most a specified number of items from the source Observable that were
+     * emitted in a specified window of time before the Observable completed, where the timing information is
+     * provided by a given Scheduler.
      * 
    
      * 
      * 
@@ -7326,9 +7360,9 @@ public final Observable takeLast(int count, long time, TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the Scheduler that provides the timestamps for the observed items
-     * @return an Observable that emits at most {@code count} items from the source Observable that
-     *         were emitted in a specified window of time before the Observable completed, where
-     *         the timing information is provided by the given {@code scheduler}
+     * @return an Observable that emits at most {@code count} items from the source Observable that were emitted
+     *         in a specified window of time before the Observable completed, where the timing information is
+     *         provided by the given {@code scheduler}
      */
     public final Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
         if (count < 0) {
@@ -7338,8 +7372,8 @@ public final Observable takeLast(int count, long time, TimeUnit unit, Schedul
     }
 
     /**
-     * Return an Observable that emits the items from the source Observable that were emitted in a
-     * specified window of time before the Observable completed.
+     * Return an Observable that emits the items from the source Observable that were emitted in a specified
+     * window of time before the Observable completed.
      * 
    
      * 
      * 
@@ -7347,17 +7381,17 @@ public final Observable takeLast(int count, long time, TimeUnit unit, Schedul
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits the items from the source Observable that were emitted in
-     *         the window of time before the Observable completed specified by {@code time}
+     * @return an Observable that emits the items from the source Observable that were emitted in the window of
+     *         time before the Observable completed specified by {@code time}
      */
     public final Observable takeLast(long time, TimeUnit unit) {
         return takeLast(time, unit, Schedulers.computation());
     }
 
     /**
-     * Return an Observable that emits the items from the source Observable that were emitted in a
-     * specified window of time before the Observable completed, where the timing information is
-     * provided by a specified scheduler.
+     * Return an Observable that emits the items from the source Observable that were emitted in a specified
+     * window of time before the Observable completed, where the timing information is provided by a specified
+     * Scheduler.
      * 
    
      * 
      * 
@@ -7367,33 +7401,32 @@ public final Observable takeLast(long time, TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the Scheduler that provides the timestamps for the Observed items
-     * @return an Observable that emits the items from the source Observable that were emitted in
-     *         the window of time before the Observable completed specified by {@code time}, where
-     *         the timing information is provided by {@code scheduler}
+     * @return an Observable that emits the items from the source Observable that were emitted in the window of
+     *         time before the Observable completed specified by {@code time}, where the timing information is
+     *         provided by {@code scheduler}
      */
     public final Observable takeLast(long time, TimeUnit unit, Scheduler scheduler) {
         return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
     }
 
     /**
-     * Return an Observable that emits a single List containing the last {@code count} elements
-     * emitted by the source Observable.
+     * Return an Observable that emits a single List containing the last {@code count} elements emitted by the
+     * source Observable.
      * 
    
      * 
      * 
      * @param count
      *            the number of items to emit in the list
-     * @return an Observable that emits a single list containing the last {@code count} elements
-     *         emitted by the source Observable
+     * @return an Observable that emits a single list containing the last {@code count} elements emitted by the
+     *         source Observable
      */
     public final Observable> takeLastBuffer(int count) {
         return takeLast(count).toList();
     }
 
     /**
-     * Return an Observable that emits a single List containing at most {@code count} items from
-     * the source Observable that were emitted during a specified window of time before the
-     * source Observable completed.
+     * Return an Observable that emits a single List containing at most {@code count} items from the source
+     * Observable that were emitted during a specified window of time before the source Observable completed.
      * 
    
      * 
      * 
@@ -7403,18 +7436,18 @@ public final Observable> takeLastBuffer(int count) {
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits a single List containing at most {@code count} items emitted
-     *         by the source Observable during the time window defined by {@code time} before the
-     *         source Observable completed
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the
+     *         source Observable during the time window defined by {@code time} before the source Observable
+     *         completed
      */
     public final Observable> takeLastBuffer(int count, long time, TimeUnit unit) {
         return takeLast(count, time, unit).toList();
     }
 
     /**
-     * Return an Observable that emits a single List containing at most {@code count} items from
-     * the source Observable that were emitted during a specified window of time (on a specified
-     * scheduler) before the source Observable completed.
+     * Return an Observable that emits a single List containing at most {@code count} items from the source
+     * Observable that were emitted during a specified window of time (on a specified Scheduler) before the
+     * source Observable completed.
      * 
    
      * 
      * 
@@ -7425,19 +7458,18 @@ public final Observable> takeLastBuffer(int count, long time, TimeUnit u
      * @param unit
      *            the time unit of {@code time}
      * @param scheduler
-     *            the scheduler that provides the timestamps for the observed items
-     * @return an Observable that emits a single List containing at most {@code count} items emitted
-     *         by the source Observable during the time window defined by {@code time} before the
-     *         source Observable completed
+     *            the Scheduler that provides the timestamps for the observed items
+     * @return an Observable that emits a single List containing at most {@code count} items emitted by the
+     *         source Observable during the time window defined by {@code time} before the source Observable
+     *         completed
      */
     public final Observable> takeLastBuffer(int count, long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(count, time, unit, scheduler).toList();
     }
 
     /**
-     * Return an Observable that emits a single List containing those items from the source
-     * Observable that were emitted during a specified window of time before the source Observable
-     * completed.
+     * Return an Observable that emits a single List containing those items from the source Observable that were
+     * emitted during a specified window of time before the source Observable completed.
      * 
    
      * 
      * 
@@ -7445,18 +7477,17 @@ public final Observable> takeLastBuffer(int count, long time, TimeUnit u
      *            the length of the time window
      * @param unit
      *            the time unit of {@code time}
-     * @return an Observable that emits a single List containing the items emitted by the source
-     *         Observable during the time window defined by {@code time} before the source
-     *         Observable completed
+     * @return an Observable that emits a single List containing the items emitted by the source Observable
+     *         during the time window defined by {@code time} before the source Observable completed
      */
     public final Observable> takeLastBuffer(long time, TimeUnit unit) {
         return takeLast(time, unit).toList();
     }
 
     /**
-     * Return an Observable that emits a single List containing those items from the source
-     * Observable that were emitted during a specified window of time before the source Observable
-     * completed, where the timing information is provided by the given Scheduler.
+     * Return an Observable that emits a single List containing those items from the source Observable that were
+     * emitted during a specified window of time before the source Observable completed, where the timing
+     * information is provided by the given Scheduler.
      * 
    
      * 
      * 
@@ -7466,27 +7497,27 @@ public final Observable> takeLastBuffer(long time, TimeUnit unit) {
      *            the time unit of {@code time}
      * @param scheduler
      *            the Scheduler that provides the timestamps for the observed items
-     * @return an Observable that emits a single List containing the items emitted by the source
-     *         Observable during the time window defined by {@code time} before the source
-     *         Observable completed, where the timing information is provided by {@code scheduler}
+     * @return an Observable that emits a single List containing the items emitted by the source Observable
+     *         during the time window defined by {@code time} before the source Observable completed, where the
+     *         timing information is provided by {@code scheduler}
      */
     public final Observable> takeLastBuffer(long time, TimeUnit unit, Scheduler scheduler) {
         return takeLast(time, unit, scheduler).toList();
     }
 
     /**
-     * Returns an Observable that emits the items emitted by the source Observable until a second
-     * Observable emits an item.
+     * Returns an Observable that emits the items emitted by the source Observable until a second Observable
+     * emits an item.
      * 
    
      * 
      * 
      * @param other
-     *            the Observable whose first emitted item will cause {@code takeUntil} to stop
-     *            emitting items from the source Observable
+     *            the Observable whose first emitted item will cause {@code takeUntil} to stop emitting items
+     *            from the source Observable
      * @param 
      *            the type of items emitted by {@code other}
-     * @return an Observable that emits the items emitted by the source Observable until such time
-     *         as {@code other} emits its first item
+     * @return an Observable that emits the items emitted by the source Observable until such time as
+     *         {@code other} emits its first item
      * @see RxJava Wiki: takeUntil()
      */
     public final  Observable takeUntil(Observable other) {
@@ -7494,17 +7525,15 @@ public final  Observable takeUntil(Observable other) {
     }
 
     /**
-     * Returns an Observable that emits items emitted by the source Observable so long as each item
-     * satisfied a specified condition, and then completes as soon as this condition is not
-     * satisfied.
+     * Returns an Observable that emits items emitted by the source Observable so long as each item satisfied a
+     * specified condition, and then completes as soon as this condition is not satisfied.
      * 
    
      * 
      * 
      * @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 {@code predicate}, then completes
+     *            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 {@code predicate}, then completes
      * @see RxJava Wiki: takeWhile()
      */
     public final Observable takeWhile(final Func1 predicate) {
@@ -7512,18 +7541,18 @@ public final Observable takeWhile(final Func1 predicate)
     }
 
     /**
-     * Returns an Observable that emits the items emitted by a source Observable so long as a given
-     * predicate remains true, where the predicate operates on both the item and its index relative
-     * to the complete sequence of emitted items.
+     * Returns an Observable that emits the items emitted by a source Observable so long as a given predicate
+     * remains true, where the predicate operates on both the item and its index relative to the complete
+     * sequence of emitted items.
      * 
    
      * 
      * 
      * @param predicate
-     *            a function to test each item emitted by the source Observable for a condition; the
-     *            second parameter of the function represents the sequential index of the source
-     *            item; it returns a Boolean
-     * @return an Observable that emits items from the source Observable so long as the predicate
-     *         continues to return {@code true} for each item, then completes
+     *            a function to test each item emitted by the source Observable for a condition; the second
+     *            parameter of the function represents the sequential index of the source item; it returns a
+     *            Boolean
+     * @return an Observable that emits items from the source Observable so long as the predicate continues to
+     *         return {@code true} for each item, then completes
      * @see RxJava Wiki: takeWhileWithIndex()
      */
     public final Observable takeWhileWithIndex(final Func2 predicate) {
@@ -7531,15 +7560,15 @@ public final Observable takeWhileWithIndex(final Func2
      * 
      * 
      * @param selector
      *            selector that will be invoked for items emitted by the source Observable
-     * @return a {@link Plan} that produces the projected results, to be fed (with other Plans) to
-     *         the {@link #when} Observer
+     * @return a {@link Plan} that produces the projected results, to be fed (with other Plans) to the
+     *         {@link #when} Observer
      * @throws NullPointerException
      *             if {@code selector} is null
      * @see RxJava Wiki: then()
@@ -7550,10 +7579,11 @@ public final  Plan0 then(Func1 selector) {
     }
 
     /**
-     * Returns an Observable that emits only the first item emitted by the source Observable during
-     * sequential time windows of a specified duration.
+     * Returns an Observable that emits only the first item emitted by the source Observable during sequential
+     * time windows of a specified duration.
      * 
    
-     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas
+     * {@link #throttleLast} ticks at scheduled intervals.
      * 
    
      * 
      * 
@@ -7569,11 +7599,11 @@ public final Observable throttleFirst(long windowDuration, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits only the first item emitted by the source Observable during
-     * sequential time windows of a specified duration, where the windows are managed by a specified
-     * Scheduler.
+     * Returns an Observable that emits only the first item emitted by the source Observable during sequential
+     * time windows of a specified duration, where the windows are managed by a specified Scheduler.
      * 
    
-     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas
+     * {@link #throttleLast} ticks at scheduled intervals.
      * 
    
      * 
      * 
@@ -7582,8 +7612,8 @@ public final Observable throttleFirst(long windowDuration, TimeUnit unit) {
      * @param unit
      *            the unit of time of {@code skipDuration}
      * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the timers that handle timeout
-     *            for each event
+     *            the {@link Scheduler} to use internally to manage the timers that handle timeout for each
+     *            event
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleFirst()
      */
@@ -7592,17 +7622,17 @@ public final Observable throttleFirst(long skipDuration, TimeUnit unit, Sched
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source Observable during
-     * sequential time windows of a specified duration.
+     * Returns an Observable that emits only the last item emitted by the source Observable during sequential
+     * time windows of a specified duration.
      * 
    
-     * This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval
-     * whereas {@link #throttleFirst} does not tick, it just tracks passage of time.
+     * This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas
+     * {@link #throttleFirst} does not tick, it just tracks passage of time.
      * 
    
      * 
      * 
      * @param intervalDuration
-     *            duration of windows within which the last item emitted by the source Observable
-     *            will be emitted
+     *            duration of windows within which the last item emitted by the source Observable will be
+     *            emitted
      * @param unit
      *            the unit of time of {@code intervalDuration}
      * @return an Observable that performs the throttle operation
@@ -7614,23 +7644,22 @@ public final Observable throttleLast(long intervalDuration, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits only the last item emitted by the source Observable during
-     * sequential time windows of a specified duration, where the duration is governed by a
-     * specified Scheduler.
+     * Returns an Observable that emits only the last item emitted by the source Observable during sequential
+     * time windows of a specified duration, where the duration is governed by a specified Scheduler.
      * 
    
-     * This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval
-     * whereas {@link #throttleFirst} does not tick, it just tracks passage of time.
+     * This differs from {@link #throttleFirst} in that this ticks along at a scheduled interval whereas
+     * {@link #throttleFirst} does not tick, it just tracks passage of time.
      * 
    
      * 
      * 
      * @param intervalDuration
-     *            duration of windows within which the last item emitted by the source Observable
-     *            will be emitted
+     *            duration of windows within which the last item emitted by the source Observable will be
+     *            emitted
      * @param unit
      *            the unit of time of {@code intervalDuration}
      * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the timers that handle timeout
-     *            for each event
+     *            the {@link Scheduler} to use internally to manage the timers that handle timeout for each
+     *            event
      * @return an Observable that performs the throttle operation
      * @see RxJava Wiki: throttleLast()
      * @see #sample(long, TimeUnit, Scheduler)
@@ -7640,11 +7669,11 @@ public final Observable throttleLast(long intervalDuration, TimeUnit unit, Sc
     }
 
     /**
-     * Returns an Observable that only emits those items emitted by the source Observable that are
-     * not followed by another emitted item within a specified time window.
+     * Returns an Observable that only emits those items emitted by the source Observable that are not followed
+     * by another emitted item within a specified time window.
      * 
    
-     * Note: If the source Observable keeps emitting items more frequently than the length
-     * of the time window then no items will be emitted by the resulting Observable.
+     * Note: If the source Observable keeps emitting items more frequently than the length of the time
+     * window then no items will be emitted by the resulting Observable.
      * 
    
      * 
      * 
    
@@ -7657,9 +7686,9 @@ public final Observable throttleLast(long intervalDuration, TimeUnit unit, Sc
      * 
      * 
      * @param timeout
-     *            the length of the window of time that must pass after the emission of an item from
-     *            the source Observable in which that Observable emits no items in order for the
-     *            item to be emitted by the resulting Observable
+     *            the length of the window of time that must pass after the emission of an item from the source
+     *            Observable in which that Observable emits no items in order for the item to be emitted by the
+     *            resulting Observable
      * @param unit
      *            the {@link TimeUnit} of {@code timeout}
      * @return an Observable that filters out items that are too quickly followed by newer items
@@ -7671,12 +7700,12 @@ public final Observable throttleWithTimeout(long timeout, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that only emits those items emitted by the source Observable that are
-     * not followed by another emitted item within a specified time window, where the time window
-     * is governed by a specified Scheduler.
+     * Returns an Observable that only emits those items emitted by the source Observable that are not followed
+     * by another emitted item within a specified time window, where the time window is governed by a specified
+     * Scheduler.
      * 
    
-     * Note: If the source Observable keeps emitting items more frequently than the length
-     * of the time window then no items will be emitted by the resulting Observable.
+     * Note: If the source Observable keeps emitting items more frequently than the length of the time
+     * window then no items will be emitted by the resulting Observable.
      * 
    
      * 
      * 
    
@@ -7689,14 +7718,14 @@ public final Observable throttleWithTimeout(long timeout, TimeUnit unit) {
      * 
      * 
      * @param timeout
-     *            the length of the window of time that must pass after the emission of an item from
-     *            the source Observable in which that Observable emits no items in order for the
-     *            item to be emitted by the resulting Observable
+     *            the length of the window of time that must pass after the emission of an item from the source
+     *            Observable in which that Observable emits no items in order for the item to be emitted by the
+     *            resulting Observable
      * @param unit
      *            the {@link TimeUnit} of {@code timeout}
      * @param scheduler
-     *            the {@link Scheduler} to use internally to manage the timers that handle the
-     *            timeout for each item
+     *            the {@link Scheduler} to use internally to manage the timers that handle the timeout for each
+     *            item
      * @return an Observable that filters out items that are too quickly followed by newer items
      * @see RxJava Wiki: throttleWithTimeout()
      * @see #debounce(long, TimeUnit, Scheduler)
@@ -7706,8 +7735,8 @@ public final Observable throttleWithTimeout(long timeout, TimeUnit unit, Sche
     }
 
     /**
-     * Returns an Observable that emits records of the time interval between consecutive items
-     * emitted by the source Observable.
+     * Returns an Observable that emits records of the time interval between consecutive items emitted by the
+     * source Observable.
      * 
    
      * 
      * 
@@ -7720,8 +7749,8 @@ public final Observable> timeInterval() {
     }
 
     /**
-     * Returns an Observable that emits records of the time interval between consecutive items
-     * emitted by the source Observable, where this interval is computed on a specified Scheduler.
+     * Returns an Observable that emits records of the time interval between consecutive items emitted by the
+     * source Observable, where this interval is computed on a specified Scheduler.
      * 
    
      * 
      * 
@@ -7736,9 +7765,9 @@ public final Observable> timeInterval(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable, but emits a TimeoutException
-     * if either the first item emitted by the source Observable or any subsequent item
-     * don't arrive within time windows defined by other Observables.
+     * Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if
+     * either the first item emitted by the source Observable or any subsequent item don't arrive within time
+     * windows defined by other Observables.
      * 
    
      * 
      * 
@@ -7747,23 +7776,24 @@ public final Observable> timeInterval(Scheduler scheduler) {
      * @param 
      *            the subsequent timeout value type (ignored)
      * @param firstTimeoutSelector
-     *            a function that returns an Observable that determines the timeout window for the
-     *            first source item
+     *            a function that returns an Observable that determines the timeout window for the first source
+     *            item
      * @param timeoutSelector
-     *            a function that returns an Observable for each item emitted by the source
-     *            Observable and that determines the timeout window in which the subsequent source
-     *            item must arrive in order to continue the sequence
-     * @return an Observable that mirrors the source Observable, but emits a TimeoutException if 
-     *         either the first item or any subsequent item doesn't arrive within the time windows specified by the timeout selectors
+     *            a function that returns an Observable for each item emitted by the source Observable and that
+     *            determines the timeout window in which the subsequent source item must arrive in order to
+     *            continue the sequence
+     * @return an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if
+     *         either the first item or any subsequent item doesn't arrive within the time windows specified by
+     *         the timeout selectors
      */
     public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector) {
         return timeout(firstTimeoutSelector, timeoutSelector, null);
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable, but switches to a fallback
-     * Observable if either the first item emitted by the source Observable or any subsequent item
-     * don't arrive within time windows defined by other Observables.
+     * Returns an Observable that mirrors the source Observable, but switches to a fallback Observable if either
+     * the first item emitted by the source Observable or any subsequent item don't arrive within time windows
+     * defined by other Observables.
      * 
    
      * 
      * 
@@ -7772,16 +7802,17 @@ public final  Observable timeout(Func0> firstTi
      * @param 
      *            the subsequent timeout value type (ignored)
      * @param firstTimeoutSelector
-     *            a function that returns an Observable which determines the timeout window for the
-     *            first source item
+     *            a function that returns an Observable which determines the timeout window for the first source
+     *            item
      * @param timeoutSelector
-     *            a function that returns an Observable for each item emitted by the source
-     *            Observable and that determines the timeout window in which the subsequent source
-     *            item must arrive in order to continue the sequence
+     *            a function that returns an Observable for each item emitted by the source Observable and that
+     *            determines the timeout window in which the subsequent source item must arrive in order to
+     *            continue the sequence
      * @param other
      *            the fallback Observable to switch to if the source Observable times out
-     * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if either the first item emitted by the source Observable or any
-     *         subsequent item don't arrive within time windows defined by the timeout selectors
+     * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if
+     *         either the first item emitted by the source Observable or any subsequent item don't arrive within
+     *         time windows defined by the timeout selectors
      */
     public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
         if(timeoutSelector == null) {
@@ -7791,10 +7822,10 @@ public final  Observable timeout(Func0> firstTi
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable, but emits a TimeoutException if an item emitted by
-     * the source Observable doesn't arrive within a window of time after the emission of the
-     * previous item, where that period of time is measured by an Observable that is a function
-     * of the previous item.
+     * Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if
+     * an item emitted by the source Observable doesn't arrive within a window of time after the emission of the
+     * previous item, where that period of time is measured by an Observable that is a function of the previous
+     * item.
      * 
    
      * 
      * 
    
@@ -7805,19 +7836,19 @@ public final  Observable timeout(Func0> firstTi
      * @param timeoutSelector
      *            a function that returns an observable for each item emitted by the source
      *            Observable and that determines the timeout window for the subsequent item
-     * @return an Observable that mirrors the source Observable, but emits a TimeoutException if a item emitted by
-     *         the source Observable takes longer to arrive than the time window defined by the
-     *         selector for the previously emitted item
+     * @return an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if
+     *         an item emitted by the source Observable takes longer to arrive than the time window defined by
+     *         the selector for the previously emitted item
      */
     public final  Observable timeout(Func1> timeoutSelector) {
         return timeout(null, timeoutSelector, null);
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable, but that switches to a fallback
-     * Observable if an item emitted by the source Observable doesn't arrive within a window of time
-     * after the emission of the previous item, where that period of time is measured by an
-     * Observable that is a function of the previous item.
+     * Returns an Observable that mirrors the source Observable, but that switches to a fallback Observable if
+     * an item emitted by the source Observable doesn't arrive within a window of time after the emission of the
+     * previous item, where that period of time is measured by an Observable that is a function of the previous
+     * item.
      * 
    
      * 
      * 
    
@@ -7826,23 +7857,22 @@ public final  Observable timeout(Func1>
      * @param 
      *            the timeout value type (ignored)
      * @param timeoutSelector
-     *            a function that returns an observable for each item emitted by the source
-     *            Observable and that determines the timeout window for the subsequent item
+     *            a function that returns an Observable, for each item emitted by the source Observable, that
+     *            determines the timeout window for the subsequent item
      * @param other
      *            the fallback Observable to switch to if the source Observable times out
-     * @return an Observable that mirrors the source Observable, but switches to mirroring a
-     *         fallback Observable if a item emitted by the source Observable takes longer to arrive
-     *         than the time window defined by the selector for the previously emitted item
+     * @return an Observable that mirrors the source Observable, but switches to mirroring a fallback Observable
+     *         if an item emitted by the source Observable takes longer to arrive than the time window defined
+     *         by the selector for the previously emitted item
      */
     public final  Observable timeout(Func1> timeoutSelector, Observable other) {
         return timeout(null, timeoutSelector, other);
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable but applies a timeout policy for
-     * each emitted item. If the next item isn't emitted within the specified timeout duration
-     * starting from its predecessor, the resulting Observable terminates and notifies observers of
-     * a {@code TimeoutException}.
+     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
+     * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor,
+     * the resulting Observable terminates and notifies observers of a {@code TimeoutException}.
      * 
    
      * 
      * 
@@ -7850,8 +7880,8 @@ public final  Observable timeout(Func1>
      *            maximum duration between emitted items before a timeout occurs
      * @param timeUnit
      *            the unit of time that applies to the {@code timeout} argument.
-     * @return the source Observable modified to notify observers of a {@code TimeoutException} in
-     *         case of a timeout
+     * @return the source Observable modified to notify observers of a {@code TimeoutException} in case of a
+     *         timeout
      * @see RxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
@@ -7860,10 +7890,9 @@ public final Observable timeout(long timeout, TimeUnit timeUnit) {
     }
 
     /**
-     * Returns an Observable that mirrors the source Observable but applies a timeout policy for
-     * each emitted item. If the next item isn't emitted within the specified timeout duration
-     * starting from its predecessor, the resulting Observable begins instead to mirror a fallback
-     * Observable.
+     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
+     * item. If the next item isn't emitted within the specified timeout duration starting from its predecessor,
+     * the resulting Observable begins instead to mirror a fallback Observable.
      * 
    
      * 
      * 
@@ -7873,8 +7902,7 @@ public final Observable timeout(long timeout, TimeUnit timeUnit) {
      *            the unit of time that applies to the {@code timeout} argument
      * @param other
      *            the fallback Observable to use in case of a timeout
-     * @return the source Observable modified to switch to the fallback Observable in case of a
-     *         timeout
+     * @return the source Observable modified to switch to the fallback Observable in case of a timeout
      * @see RxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
@@ -7883,10 +7911,9 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, Observable
      * 
      * 
@@ -7898,8 +7925,8 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, ObservableRxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
@@ -7908,10 +7935,10 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, Observable
      * 
      * 
@@ -7921,8 +7948,8 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, ObservableRxJava Wiki: timeout()
      * @see MSDN: Observable.Timeout
      */
@@ -7931,7 +7958,8 @@ public final Observable timeout(long timeout, TimeUnit timeUnit, Scheduler sc
     }
 
     /**
-     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a {@link Timestamped} object.
+     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a
+     * {@link Timestamped} object.
      * 
    
      * 
      * 
@@ -7944,14 +7972,15 @@ public final Observable> timestamp() {
     }
 
     /**
-     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a {@link Timestamped} object whose timestamps are provided by a specified Scheduler.
+     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a
+     * {@link Timestamped} object whose timestamps are provided by a specified Scheduler.
      * 
    
      * 
      * 
      * @param scheduler
      *            the {@link Scheduler} to use as a time source
-     * @return an Observable that emits timestamped items from the source Observable with timestamps
-     *         provided by the {@code scheduler}
+     * @return an Observable that emits timestamped items from the source Observable with timestamps provided by
+     *         the {@code scheduler}
      * @see RxJava Wiki: timestamp()
      * @see MSDN: Observable.Timestamp
      */
@@ -7960,8 +7989,7 @@ public final Observable> timestamp(Scheduler scheduler) {
     }
 
     /**
-     * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking
-     * Observers).
+     * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
      * 
      * @return a {@code BlockingObservable} version of this Observable
      * @see RxJava Wiki: Blocking Observable Observers
@@ -7971,21 +7999,25 @@ public final BlockingObservable toBlockingObservable() {
     }
 
     /**
-     * Returns an Observable that emits a single item, a list composed of all the items emitted by
-     * the source Observable.
+     * 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 {@code onNext} function once, passing it the entire list, by calling
-     * the Observable's {@code toList} method prior to calling its {@link #subscribe} method.
+     * 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 {@code onNext}
+     * function once, passing it the entire list, by calling the Observable's {@code toList} method prior to
+     * calling its {@link #subscribe} method.
      * 
    
-     * Be careful not to use this Observer on Observables that emit infinite or very large numbers
-     * of items, as you do not have the option to unsubscribe.
+     *
+     *                              
+     *
+     * 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.
+     * @return an Observable that emits a single item: a List containing all of the items emitted by the source
+     *         Observable
      * @see RxJava Wiki: toList()
      */
     public final Observable> toList() {
@@ -7993,18 +8025,17 @@ public final Observable> toList() {
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing all items emitted by the source
-     * Observable, mapped by the keys returned by a specified {@code keySelector} function.
+     * Return an Observable that emits a single HashMap containing all items emitted by the source Observable,
+     * mapped by the keys returned by a specified {@code keySelector} function.
      * 
    
      * 
      * 
    
-     * If more than one source item maps to the same key, the HashMap will contain the latest of
-     * those items.
+     * If more than one source item maps to the same key, the HashMap will contain the latest of those items.
      * 
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the HashMap
-     * @return an Observable that emits a single item: a HashMap containing the mapped items from
-     *         the source Observable
+     * @return an Observable that emits a single item: a HashMap containing the mapped items from the source
+     *         Observable
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
@@ -8013,20 +8044,20 @@ public final  Observable> toMap(Func1 keySe
     }
 
     /**
-     * Return an Observable that emits a single HashMap containing values corresponding to items
-     * emitted by the source Observable, mapped by the keys returned by a specified {@code keySelector} function.
+     * Return an Observable that emits a single HashMap containing values corresponding to items emitted by the
+     * source Observable, mapped by the keys returned by a specified {@code keySelector} function.
      * 
    
      * 
      * 
    
-     * If more than one source item maps to the same key, the HashMap will contain a single entry
-     * that corresponds to the latest of those items.
+     * If more than one source item maps to the same key, the HashMap will contain a single entry that
+     * corresponds to the latest of those items.
      * 
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the HashMap
      * @param valueSelector
      *            the function that extracts the value from a source item to be used in the HashMap
-     * @return an Observable that emits a single item: a HashMap containing the mapped items from
-     *         the source Observable
+     * @return an Observable that emits a single item: a HashMap containing the mapped items from the source
+     *         Observable
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToDictionary
      */
@@ -8035,20 +8066,19 @@ public final  Observable> toMap(Func1 ke
     }
 
     /**
-     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that contains keys and values extracted from the items emitted by the source
-     * Observable.
+     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that
+     * contains keys and values extracted from the items emitted by the source Observable.
      * 
    
      * 
      * 
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the Map
      * @param valueSelector
-     *            the function that extracts the value from the source items to be used as value in
-     *            the Map
+     *            the function that extracts the value from the source items to be used as value in the Map
      * @param mapFactory
      *            the function that returns a Map instance to be used
-     * @return an Observable that emits a single item: a Map that contains the mapped items emitted
-     *         by the source Observable
+     * @return an Observable that emits a single item: a Map that contains the mapped items emitted by the
+     *         source Observable
      * @see RxJava Wiki: toMap()
      */
     public final  Observable> toMap(Func1 keySelector, Func1 valueSelector, Func0> mapFactory) {
@@ -8056,16 +8086,15 @@ public final  Observable> toMap(Func1 ke
     }
 
     /**
-     * Return an Observable that emits a single HashMap that contains an ArrayList of items emitted
-     * by the source Observable keyed by a specified {@code keySelector} function.
+     * Return an Observable that emits a single HashMap that contains an ArrayList of items emitted by the
+     * source Observable keyed by a specified {@code keySelector} function.
      * 
    
      * 
      * 
      * @param keySelector
-     *            the function that extracts the key from the source items to be used as key in the
-     *            HashMap
-     * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items
-     *         mapped from the source Observable
+     *            the function that extracts the key from the source items to be used as key in the HashMap
+     * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from
+     *         the source Observable
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
@@ -8074,20 +8103,18 @@ public final  Observable>> toMultimap(Func1
      * 
      * 
      * @param keySelector
-     *            the function that extracts a key from the source items to be used as key in the
-     *            HashMap
+     *            the function that extracts a key from the source items to be used as key in the HashMap
      * @param valueSelector
-     *            the function that extracts a value from the source items to be used as value in
-     *            the HashMap
-     * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items
-     *         mapped from the source Observable
+     *            the function that extracts a value from the source items to be used as value in the HashMap
+     * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from
+     *         the source Observable
      * @see RxJava Wiki: toMap()
      * @see MSDN: Observable.ToLookup
      */
@@ -8096,21 +8123,20 @@ public final  Observable>> toMultimap(Func1
      * 
      * 
      * @param keySelector
-     *            the function that extracts a key from the source items to be used as the key in
-     *            the Map
+     *            the function that extracts a key from the source items to be used as the key in the Map
      * @param valueSelector
-     *            the function that extracts a value from the source items to be used as the value
-     *            in the Map
+     *            the function that extracts a value from the source items to be used as the value in the Map
      * @param mapFactory
      *            the function that returns a Map instance to be used
-     * @return an Observable that emits a single item: a Map that contains a list items mapped
-     *         from the source Observable
+     * @return an Observable that emits a single item: a Map that contains a list items mapped from the source
+     *         Observable
      * @see RxJava Wiki: toMap()
      */
     public final  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory) {
@@ -8118,24 +8144,22 @@ public final  Observable>> toMultimap(Func1
      * 
      * 
      * @param keySelector
-     *            the function that extracts a key from the source items to be used as the key in
-     *            the Map
+     *            the function that extracts a key from the source items to be used as the key in the Map
      * @param valueSelector
-     *            the function that extracts a value from the source items to be used as the value
-     *            in the Map
+     *            the function that extracts a value from the source items to be used as the value in the Map
      * @param mapFactory
      *            the function that returns a Map instance to be used
      * @param collectionFactory
-     *            the function that returns a Collection instance for a particular key to be used in
-     *            the Map
-     * @return an Observable that emits a single item: a Map that contains the collection of mapped
-     *         items from the source Observable
+     *            the function that returns a Collection instance for a particular key to be used in the Map
+     * @return an Observable that emits a single item: a Map that contains the collection of mapped items from
+     *         the source Observable
      * @see RxJava Wiki: toMap()
      */
     public final  Observable>> toMultimap(Func1 keySelector, Func1 valueSelector, Func0>> mapFactory, Func1> collectionFactory) {
@@ -8143,16 +8167,17 @@ public final  Observable>> toMultimap(Func1
      * 
      * 
      * @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 a list that contains the items emitted by the source
-     *         Observable in sorted order
+     *             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 a list that contains the items emitted by the source Observable in
+     *         sorted order
      * @see RxJava Wiki: toSortedList()
      */
     public final Observable> toSortedList() {
@@ -8160,16 +8185,16 @@ public final Observable> toSortedList() {
     }
 
     /**
-     * Returns an Observable that emits a list that contains the items emitted by the source
-     * Observable, in a sorted order based on a specified comparison function.
+     * Returns an Observable that emits a list that contains 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 a list that contains the items emitted by the source
-     *         Observable in sorted order
+     *            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 a list that contains the items emitted by the source Observable in
+     *         sorted order
      * @see RxJava Wiki: toSortedList()
      */
     public final Observable> toSortedList(Func2 sortFunction) {
@@ -8182,11 +8207,13 @@ public final Observable> toSortedList(Func2
      * 
      * @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 emitted by the source Observable that the
-     *         filter evaluates as {@code true}
+     *            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 emitted by the source Observable that the filter
+     *         evaluates as {@code true}
      * @see RxJava Wiki: where()
      * @see #filter(Func1)
+     * @deprecated use {@link #filter(Func1)}
      */
     @Deprecated
     public final Observable where(Func1 predicate) {
@@ -8194,19 +8221,18 @@ public final Observable where(Func1 predicate) {
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping windows. It emits the current
-     * window and opens a new one when the Observable produced by the specified {@code closingSelector} emits an item. The {@code closingSelector} then creates a new
-     * Observable to generate the closer of the next window.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows. It emits the current window and opens a new one when
+     * the Observable produced by the specified {@code closingSelector} emits an item. The
+     * {@code closingSelector} then creates a new Observable to generate the closer of the next window.
      * 
    
      * 
      * 
      * @param closingSelector
-     *            a {@link Func0} that produces an Observable for every window created. When this
-     *            Observable emits an item, {@code window()} emits the associated window and begins
-     *            a new one.
-     * @return an Observable that emits connected, non-overlapping windows of items from the source
-     *         Observable when {@code closingSelector} emits an item
+     *            a {@link Func0} that produces an Observable for every window created. When this Observable
+     *            emits an item, {@code window()} emits the associated window and begins a new one.
+     * @return an Observable that emits connected, non-overlapping windows of items from the source Observable
+     *         when {@code closingSelector} emits an item
      * @see RxJava Wiki: window()
      */
     public final  Observable> window(Func0> closingSelector) {
@@ -8214,16 +8240,17 @@ public final  Observable> window(Func0
      * 
      * 
      * @param count
      *            the maximum size of each window before it should be emitted
-     * @return an Observable that emits connected, non-overlapping windows, each containing at most {@code count} items from the source Observable
+     * @return an Observable that emits connected, non-overlapping windows, each containing at most
+     *         {@code count} items from the source Observable
      * @see RxJava Wiki: window()
      */
     public final Observable> window(int count) {
@@ -8231,19 +8258,20 @@ public final Observable> window(int count) {
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits windows every {@code skip} items, each containing
-     * no more than {@code count} items. When the source Observable completes or encounters an
-     * error, the resulting Observable emits the current window and propagates the notification from
-     * the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits windows every {@code skip} items, each containing no more than {@code count} items. When
+     * the source Observable completes or encounters an error, the resulting Observable emits the current window
+     * and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param count
      *            the maximum size of each window before it should be emitted
      * @param skip
-     *            how many items need to be skipped before starting a new window. Note that if {@code skip} and {@code count} are equal this is the same operation as {@link #window(int)}.
-     * @return an Observable that emits windows every {@code skip} items containing at most {@code count} items from the source Observable
+     *            how many items need to be skipped before starting a new window. Note that if {@code skip} and
+     *            {@code count} are equal this is the same operation as {@link #window(int)}.
+     * @return an Observable that emits windows every {@code skip} items containing at most {@code count} items
+     *         from the source Observable
      * @see RxJava Wiki: window()
      */
     public final Observable> window(int count, int skip) {
@@ -8251,11 +8279,11 @@ public final Observable> window(int count, int skip) {
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits each window after a fixed timespan, specified by the {@code timespan}
-     * argument. When the source Observable completes or Observable completes or
-     * encounters an error, the resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits
+     * each window after a fixed timespan, specified by the {@code timespan} argument. When the source
+     * Observable completes or Observable completes or encounters an error, the resulting Observable emits the
+     * current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
@@ -8273,11 +8301,11 @@ public final Observable> window(long timespan, long timeshift, Tim
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits each window after a fixed timespan, specified by the {@code timespan}
-     * argument. When the source Observable completes or Observable completes or
-     * encounters an error, the resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable starts a new window periodically, as determined by the {@code timeshift} argument. It emits
+     * each window after a fixed timespan, specified by the {@code timespan} argument. When the source
+     * Observable completes or Observable completes or encounters an error, the resulting Observable emits the
+     * current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
@@ -8297,21 +8325,20 @@ public final Observable> window(long timespan, long timeshift, Tim
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping windows, each of a fixed duration
-     * specified by the {@code timespan} argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows, each of a fixed duration specified by the
+     * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting
+     * Observable emits the current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each window collects items before it should be emitted and
-     *            replaced with a new window
+     *            the period of time each window collects items before it should be emitted and replaced with a
+     *            new window
      * @param unit
      *            the unit of time that applies to the {@code timespan} argument
-     * @return an Observable that emits connected, non-overlapping windows represending items
-     *         emitted by the source Observable during fixed, consecutive durations
+     * @return an Observable that emits connected, non-overlapping windows represending items emitted by the
+     *         source Observable during fixed, consecutive durations
      * @see RxJava Wiki: window()
      */
     public final Observable> window(long timespan, TimeUnit unit) {
@@ -8319,24 +8346,24 @@ public final Observable> window(long timespan, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping windows, each of a fixed duration
-     * as specified by the {@code timespan} argument or a maximum size as specified by the {@code count} argument (whichever is reached first). When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the
+     * {@code timespan} argument or a maximum size as specified by the {@code count} argument (whichever is
+     * reached first). When the source Observable completes or encounters an error, the resulting Observable
+     * emits the current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each window collects items before it should be emitted and
-     *            replaced with a new window
+     *            the period of time each window collects items before it should be emitted and replaced with a
+     *            new window
      * @param unit
      *            the unit of time that applies to the {@code timespan} argument
      * @param count
      *            the maximum size of each window before it should be emitted
-     * @return an Observable that emits connected, non-overlapping windows of items from the source
-     *         Observable that were emitted during a fixed duration of time or when the window has
-     *         reached maximum capacity (whichever occurs first)
+     * @return an Observable that emits connected, non-overlapping windows of items from the source Observable
+     *         that were emitted during a fixed duration of time or when the window has reached maximum capacity
+     *         (whichever occurs first)
      * @see RxJava Wiki: window()
      */
     public final Observable> window(long timespan, TimeUnit unit, int count) {
@@ -8344,26 +8371,26 @@ public final Observable> window(long timespan, TimeUnit unit, int
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable. The
-     * resulting Observable emits connected, non-overlapping windows, each of a fixed duration
-     * specified by the {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached first). When the source Observable completes or encounters an
-     * error, the resulting Observable emits the current window and propagates the notification from
-     * the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows, each of a fixed duration specified by the
+     * {@code timespan} argument or a maximum size specified by the {@code count} argument (whichever is reached
+     * first). When the source Observable completes or encounters an error, the resulting Observable emits the
+     * current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each window collects items before it should be emitted and
-     *            replaced with a new window
+     *            the period of time each window collects items before it should be emitted and replaced with a
+     *            new window
      * @param unit
      *            the unit of time which applies to the {@code 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 Observable that emits connected, non-overlapping windows of items from the source
-     *         Observable that were emitted during a fixed duration of time or when the window has
-     *         reached maximum capacity (whichever occurs first)
+     * @return an Observable that emits connected, non-overlapping windows of items from the source Observable
+     *         that were emitted during a fixed duration of time or when the window has reached maximum capacity
+     *         (whichever occurs first)
      * @see RxJava Wiki: window()
      */
     public final Observable> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
@@ -8371,23 +8398,22 @@ public final Observable> window(long timespan, TimeUnit unit, int
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits connected, non-overlapping windows, each of a fixed duration
-     * as specified by the {@code timespan} argument. When the source Observable completes or
-     * encounters an error, the resulting Observable emits the current window and propagates the
-     * notification from the source Observable.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the
+     * {@code timespan} argument. When the source Observable completes or encounters an error, the resulting
+     * Observable emits the current window and propagates the notification from the source Observable.
      * 
    
      * 
      * 
      * @param timespan
-     *            the period of time each window collects items before it should be emitted and
-     *            replaced with a new window
+     *            the period of time each window collects items before it should be emitted and replaced with a
+     *            new window
      * @param unit
      *            the unit of time which applies to the {@code timespan} argument
      * @param scheduler
      *            the {@link Scheduler} to use when determining the end and start of a window
-     * @return an Observable that emits connected, non-overlapping windows containing items emitted
-     *         by the source Observable within a fixed duration
+     * @return an Observable that emits connected, non-overlapping windows containing items emitted by the
+     *         source Observable within a fixed duration
      * @see RxJava Wiki: window()
      */
     public final Observable> window(long timespan, TimeUnit unit, Scheduler scheduler) {
@@ -8395,20 +8421,20 @@ public final Observable> window(long timespan, TimeUnit unit, Sche
     }
 
     /**
-     * Returns an Observable that emits windows of items it collects from the source Observable.
-     * The resulting Observable emits windows that contain those items emitted by the source
-     * Observable between the time when the {@code windowOpenings} Observable emits an item and when
-     * the Observable returned by {@code closingSelector} emits an item.
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits windows that contain those items emitted by the source Observable between the time when
+     * the {@code windowOpenings} Observable emits an item and when the Observable returned by
+     * {@code closingSelector} emits an item.
      * 
    
      * 
      * 
      * @param windowOpenings
      *            an Observable that, when it emits an item, causes another window to be created
      * @param closingSelector
-     *            a {@link Func1} that produces an Observable for every window created. When this
-     *            Observable emits an item, the associated window is closed and emitted
-     * @return an Observable that emits windows of items emitted by the source Observable that are
-     *         governed by the specified window-governing Observables
+     *            a {@link Func1} that produces an Observable for every window created. When this Observable
+     *            emits an item, the associated window is closed and emitted
+     * @return an Observable that emits windows of items emitted by the source Observable that are governed by
+     *         the specified window-governing Observables
      * @see RxJava Wiki: window()
      */
     public final  Observable> window(Observable windowOpenings, Func1> closingSelector) {
@@ -8416,9 +8442,9 @@ public final  Observable> window(Observable
      * 
      * 
@@ -8426,22 +8452,22 @@ public final  Observable> window(Observable Observable> window(Observable boundary) {
         return create(OperationWindow.window(this, boundary));
     }
 
     /**
-     * Returns an Observable that emits items that are the result of applying a specified function
-     * to pairs of values, one each from the source Observable and a specified Iterable sequence.
+     * Returns an Observable that emits items that are the result of applying a specified function to pairs of
+     * values, one each from the source Observable and a specified Iterable sequence.
      * 
    
      * 
      * 
    
-     * Note that the {@code other} Iterable is evaluated as items are observed from the source
-     * Observable; it is not pre-consumed. This allows you to zip infinite streams on either side.
+     * Note that the {@code other} Iterable is evaluated as items are observed from the source Observable; it is
+     * not pre-consumed. This allows you to zip infinite streams on either side.
      * 
      * @param 
      *            the type of items in the {@code other} Iterable
@@ -8450,17 +8476,18 @@ public final  Observable> window(Observable boundary) {
      * @param other
      *            the Iterable sequence
      * @param zipFunction
-     *            a function that combines the pairs of items from the Observable and the Iterable
-     *            to generate the items to be emitted by the resulting Observable
-     * @return an Observable that pairs up values from the source Observable and the {@code other} Iterable sequence and emits the results of {@code zipFunction} applied to these pairs
+     *            a function that combines the pairs of items from the Observable and the Iterable to generate
+     *            the items to be emitted by the resulting Observable
+     * @return an Observable that pairs up values from the source Observable and the {@code other} Iterable
+     *         sequence and emits the results of {@code zipFunction} applied to these pairs
      */
     public final  Observable zip(Iterable other, Func2 zipFunction) {
         return lift(new OperatorZipIterable(other, zipFunction));
     }
 
     /**
-     * Returns an Observable that emits items that are the result of applying a specified function
-     * to pairs of values, one each from the source Observable and another specified Observable.
+     * Returns an Observable that emits items that are the result of applying a specified function to pairs of
+     * values, one each from the source Observable and another specified Observable.
      * 
    
      * 
      * 
@@ -8471,9 +8498,10 @@ public final  Observable zip(Iterable other, Func2 Observable zip(Observable other, Func2 zipFunction) {
         return zip(this, other, zipFunction);
@@ -8533,14 +8561,12 @@ public void call(Subscriber observer) {
     /**
      * 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 Observer"
+     * 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 Observer"
      * 
    
-     * 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.
+     * 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 o
-     *            FIXME FIXME FIXME
      * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise
      */
     private boolean isInternalImplementation(Object o) {

From 1cac6fc588b61416db4e59930019fe3411653391 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 13 Feb 2014 12:17:46 -0800
Subject: [PATCH 392/441] Hide Buffer/Blocking SubscribeOn Behavior

- I want to have it for internal usage but am not ready to publicly expose it.
---
 rxjava-core/src/main/java/rx/Observable.java  | 25 +----------------
 .../rx/operators/OperatorSubscribeOn.java     | 27 +++++--------------
 .../rx/operators/OperatorGroupByTest.java     |  4 +--
 .../rx/operators/OperatorSubscribeOnTest.java |  8 +++---
 4 files changed, 14 insertions(+), 50 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 297e547b27..be5b2b37a4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7055,32 +7055,9 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
      * @see #subscribeOn(rx.Scheduler, int) 
      */
     public final Observable subscribeOn(Scheduler scheduler) {
-        return nest().lift(new OperatorSubscribeOn(scheduler, false));
+        return nest().lift(new OperatorSubscribeOn(scheduler));
     }
     
-    /**
-     * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified {@link Scheduler}
-     * and allows buffering some events emitted from the source in the time gap between the original and
-     * actual subscription, and any excess events will block the source until the actual subscription happens.
-     * 
    
-     * This overload should help mitigate issues when subscribing to a PublishSubject (and derivatives
-     * such as GroupedObservable in operator groupBy) and events fired between the original and actual subscriptions
-     * are lost. 
-     * 
    
-     * 
-     * 
-     * @param scheduler
-     *            the {@link Scheduler} to perform subscription and unsubscription actions on
-     * @param bufferSize the number of events to buffer before blocking the source while in the time gap,
-     *                   negative value indicates an unlimited buffer
-     * @return the source Observable modified so that its subscriptions and unsubscriptions happen
-     *         on the specified {@link Scheduler}
-     * @see RxJava Wiki: subscribeOn()
-     */
-    public final Observable subscribeOn(Scheduler scheduler, int bufferSize) {
-        return nest().lift(new OperatorSubscribeOn(scheduler, true, bufferSize));
-    }
-
     /**
      * Returns an Observable that extracts a Double from each of the items emitted by the source
      * Observable via a function you specify, and then emits the sum of these Doubles.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index a735886b5c..254a8fcf83 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -20,8 +20,6 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.observables.GroupedObservable;
-import rx.subjects.PublishSubject;
 import rx.util.functions.Action1;
 
 /**
@@ -46,8 +44,10 @@ public class OperatorSubscribeOn implements Operator> {
     /** The buffer size to avoid flooding. Negative value indicates an unbounded buffer. */
     private final int bufferSize;
 
-    public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
-        this(scheduler, dontLoseEvents, -1);
+    public OperatorSubscribeOn(Scheduler scheduler) {
+        this.scheduler = scheduler;
+        this.dontLoseEvents = false;
+        this.bufferSize = -1;
     }
 
     /**
@@ -55,15 +55,13 @@ public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents) {
      * 
      * @param scheduler
      *            the target scheduler
-     * @param dontLoseEvents
-     *            indicate that events should be buffered until the actual subscription happens
      * @param bufferSize
      *            if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
      *            block the source. -1 indicates an unbounded buffer
      */
-    public OperatorSubscribeOn(Scheduler scheduler, boolean dontLoseEvents, int bufferSize) {
+    public OperatorSubscribeOn(Scheduler scheduler, int bufferSize) {
         this.scheduler = scheduler;
-        this.dontLoseEvents = dontLoseEvents;
+        this.dontLoseEvents = true;
         this.bufferSize = bufferSize;
     }
 
@@ -82,18 +80,7 @@ public void onError(Throwable e) {
             }
 
             boolean checkNeedBuffer(Observable o) {
-                /*
-                 * Included are some Observable types known to be "hot" and thus needing
-                 * buffering when subscribing across thread boundaries otherwise
-                 * we can lose data.
-                 * 
-                 * See https://github.com/Netflix/RxJava/issues/844 for more information.
-                 */
-                return dontLoseEvents
-                        || ((o instanceof GroupedObservable)
-                        || (o instanceof PublishSubject)
-                        // || (o instanceof BehaviorSubject)
-                        );
+                return dontLoseEvents;
             }
 
             @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index ba6871e314..2f201dbb1b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -700,7 +700,7 @@ public void call() {
 
                             });
                 } else {
-                    return group.subscribeOn(Schedulers.newThread(), 1).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+                    return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 1)).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
 
                         @Override
                         public String call(Integer t1) {
@@ -826,7 +826,7 @@ public Integer call(Integer t) {
 
             @Override
             public Observable call(final GroupedObservable group) {
-                return group.subscribeOn(Schedulers.newThread(), 0).map(new Func1() {
+                return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0)).map(new Func1() {
 
                     @Override
                     public String call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index ddf883b07b..3a35f766e7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -186,7 +186,7 @@ public Subscription schedule(final Action1 action, final long d
     public void testSubscribeOnPublishSubjectWithSlowScheduler() {
         PublishSubject ps = PublishSubject.create();
         TestSubscriber ts = new TestSubscriber();
-        ps.subscribeOn(new SlowScheduler()).subscribe(ts);
+        ps.nest().lift(new OperatorSubscribeOn(new SlowScheduler(), 0)).subscribe(ts);
         ps.onNext(1);
         ps.onNext(2);
         ps.onCompleted();
@@ -220,7 +220,7 @@ public Integer call(Integer t) {
 
             @Override
             public Observable call(final GroupedObservable group) {
-                return group.subscribeOn(Schedulers.newThread()).map(new Func1() {
+                return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0)).map(new Func1() {
 
                     @Override
                     public String call(Integer t1) {
@@ -326,8 +326,8 @@ void testBoundedBufferingWithSize(int size) throws Exception {
 
         final List deltas = Collections.synchronizedList(new ArrayList());
 
-        Subscription s = timer.timestamp().subscribeOn(
-                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size).map(new Func1, Long>() {
+        Subscription s = timer.timestamp().nest().lift(new OperatorSubscribeOn>(
+                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size)).map(new Func1, Long>() {
             @Override
             public Long call(Timestamped t1) {
                 long v = System.currentTimeMillis() - t1.getTimestampMillis();

From 7084cd03e5d79e980959932d2b4e2036a1d9faf4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 13 Feb 2014 13:51:33 -0800
Subject: [PATCH 393/441] Comment on Parallel

- the previously performed observeOn changes appear to have resolved the non-determinism
---
 rxjava-core/src/main/java/rx/operators/OperatorParallel.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
index 9b1c76961d..38559e0500 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
@@ -56,6 +56,9 @@ public Integer call(T t) {
 
                             @Override
                             public Observable call(GroupedObservable g) {
+                                // Must use observeOn not subscribeOn because we have a single source behind groupBy.
+                                // The origin is already subscribed to, we are moving each group on to a new thread
+                                // but the origin itself can only be on a single thread.
                                 return f.call(g.observeOn(scheduler));
                             }
                         });

From 3f23b3a8c20e46f09fa63513975eadd20afece01 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Thu, 13 Feb 2014 13:58:04 -0800
Subject: [PATCH 394/441] javadoc: document more exception throwing

---
 rxjava-core/src/main/java/rx/Observable.java | 26 +++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 3980d48a59..ca60aab977 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1701,7 +1701,7 @@ public final static  Observable merge(IterableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
@@ -1728,7 +1728,7 @@ public final static  Observable merge(IterableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
@@ -1795,7 +1795,7 @@ public final static  Observable merge(ObservableRxJava Wiki: merge()
      * @see MSDN: Observable.Merge
@@ -2466,6 +2466,10 @@ public final static  Observable> parallelMerge(ObservableRxJava Wiki: range()
      * @see MSDN: Observable.Range
      */
@@ -5578,6 +5582,8 @@ public final Observable repeat(Scheduler scheduler) {
      *            sequence
      * @return an Observable that repeats the sequence of items emitted by the source Observable at most
      *         {@code count} times
+     * @throws IllegalArgumentException
+     *             if {@code count} is less than zero
      * @see RxJava Wiki: repeat()
      * @see MSDN: Observable.Repeat
      */
@@ -5729,6 +5735,8 @@ public final  Observable replay(Func1, ? extends Obs
      *         a {@link ConnectableObservable} that shares a single subscription to the source Observable, and
      *         replays no more than {@code bufferSize} items that were emitted within the window defined by
      *         {@code time}
+     * @throws IllegalArgumentException
+     *             if {@code bufferSize} is less than zero
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -5918,6 +5926,8 @@ public final ConnectableObservable replay(int bufferSize, long time, TimeUnit
      * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
      *         replays at most {@code bufferSize} items that were emitted during the window defined by
      *         {@code time}
+     * @throws IllegalArgumentException
+     *             if {@code bufferSize} is less than zero
      * @see RxJava Wiki: replay()
      * @see MSDN: Observable.Replay
      */
@@ -6984,7 +6994,13 @@ public void onNext(T t) {
      * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can 
      *         unsubscribe from the Observable
      * @throws IllegalStateException
+     *             if {@code subscribe()} is unable to obtain an {@code OnSubscribe<>} function
+     * @throws IllegalArgumentException
      *             if the {@link Subscriber} provided as the argument to {@code subscribe()} is {@code null}
+     * @throws OnErrorNotImplementedException
+     *             if the {@link Subscriber}'s {@code onError} method is null
+     * @throws RuntimeException
+     *             if the {@link Subscriber}'s {@code onError} method itself threw a {@code Throwable}
      */
     public final Subscription subscribe(Subscriber observer) {
         // allow the hook to intercept and/or decorate
@@ -7363,6 +7379,8 @@ public final Observable takeLast(int count, long time, TimeUnit unit) {
      * @return an Observable that emits at most {@code count} items from the source Observable that were emitted
      *         in a specified window of time before the Observable completed, where the timing information is
      *         provided by the given {@code scheduler}
+     * @throws IllegalArgumentException
+     *             if {@code count} is less than zero
      */
     public final Observable takeLast(int count, long time, TimeUnit unit, Scheduler scheduler) {
         if (count < 0) {
@@ -7813,6 +7831,8 @@ public final  Observable timeout(Func0> firstTi
      * @return an Observable that mirrors the source Observable, but switches to the {@code other} Observable if
      *         either the first item emitted by the source Observable or any subsequent item don't arrive within
      *         time windows defined by the timeout selectors
+     * @throws NullPointerException
+     *             if {@code timeoutSelector} is null
      */
     public final  Observable timeout(Func0> firstTimeoutSelector, Func1> timeoutSelector, Observable other) {
         if(timeoutSelector == null) {

From 43437fe931ac131085eb29eaa08d9e9a8b37ac7b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 13 Feb 2014 14:35:20 -0800
Subject: [PATCH 395/441] SubscribeOn Scheduler/Unsubscribe Behavior

---
 .../rx/operators/OperatorSubscribeOn.java     | 24 ++++---------------
 .../rx/operators/OperatorSubscribeOnTest.java | 22 ++++++++++-------
 2 files changed, 17 insertions(+), 29 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 254a8fcf83..b8e782ef37 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -67,7 +67,7 @@ public OperatorSubscribeOn(Scheduler scheduler, int bufferSize) {
 
     @Override
     public Subscriber> call(final Subscriber subscriber) {
-        return new Subscriber>() {
+        return new Subscriber>(subscriber) {
 
             @Override
             public void onCompleted() {
@@ -98,29 +98,13 @@ public void call(final Inner inner) {
                     return;
                 } else {
                     // no buffering (async subscribe)
-                    scheduler.schedule(new Action1() {
+                    subscriber.add(scheduler.schedule(new Action1() {
 
                         @Override
                         public void call(final Inner inner) {
-                            o.subscribe(new Subscriber(subscriber) {
-
-                                @Override
-                                public void onCompleted() {
-                                    subscriber.onCompleted();
-                                }
-
-                                @Override
-                                public void onError(Throwable e) {
-                                    subscriber.onError(e);
-                                }
-
-                                @Override
-                                public void onNext(T t) {
-                                    subscriber.onNext(t);
-                                }
-                            });
+                            o.subscribe(subscriber);
                         }
-                    });
+                    }));
                 }
             }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 3a35f766e7..3f12e441f9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -46,7 +46,7 @@
 
 public class OperatorSubscribeOnTest {
 
-    private class ThreadSubscription implements Subscription {
+    private static class ThreadSubscription implements Subscription {
         private volatile Thread thread;
 
         private final CountDownLatch latch = new CountDownLatch(1);
@@ -111,9 +111,10 @@ public void call(Subscriber t1) {
         observer.assertTerminalEvent();
     }
 
-    @Test
+    @Test(timeout = 2000)
     public void testIssue813() throws InterruptedException {
         // https://github.com/Netflix/RxJava/issues/813
+        final CountDownLatch scheduled = new CountDownLatch(1);
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch doneLatch = new CountDownLatch(1);
 
@@ -126,16 +127,14 @@ public void testIssue813() throws InterruptedException {
                     public void call(
                             final Subscriber subscriber) {
                         subscriber.add(s);
+                        scheduled.countDown();
                         try {
                             latch.await();
-                            // Already called "unsubscribe", "isUnsubscribed"
-                            // shouble be true
-                            if (!subscriber.isUnsubscribed()) {
-                                throw new IllegalStateException(
-                                        "subscriber.isUnsubscribed should be true");
-                            }
+
+                            // this should not run because the await above will be interrupted by the unsubscribe
                             subscriber.onCompleted();
                         } catch (InterruptedException e) {
+                            System.out.println("Interrupted because it is unsubscribed");
                             Thread.currentThread().interrupt();
                         } catch (Throwable e) {
                             subscriber.onError(e);
@@ -145,13 +144,17 @@ public void call(
                     }
                 }).subscribeOn(Schedulers.computation()).subscribe(observer);
 
+        // wait for scheduling
+        scheduled.await();
+        // trigger unsubscribe
         subscription.unsubscribe();
         // As unsubscribe is called in other thread, we need to wait for it.
         s.getThread();
         latch.countDown();
         doneLatch.await();
         assertEquals(0, observer.getOnErrorEvents().size());
-        assertEquals(1, observer.getOnCompletedEvents().size());
+        // 0 because the unsubscribe interrupts and prevents onCompleted from being executed
+        assertEquals(0, observer.getOnCompletedEvents().size());
     }
 
     public static class SlowScheduler extends Scheduler {
@@ -395,4 +398,5 @@ public void call(Subscriber sub) {
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         assertEquals(10, count.get());
     }
+
 }

From 54b19be072be8b25393c80faee61eed4d18da06e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 13 Feb 2014 19:22:51 -0800
Subject: [PATCH 396/441] Fix Unit Tests related to SubscribeOn

- timeout test could be interrupted when unsubscribed
- groupBy.subscribeOn needs blocking buffer
---
 .../rx/operators/OperatorSubscribeOnTest.java  | 13 +++++++------
 .../OperatorTimeoutWithSelectorTest.java       | 18 +++++++++++++-----
 2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 3f12e441f9..54d348dc3c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -300,14 +300,15 @@ public void call() {
 
                             });
                 } else {
-                    return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+                    return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0))
+                            .delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
 
-                        @Override
-                        public String call(Integer t1) {
-                            return "last group: " + t1;
-                        }
+                                @Override
+                                public String call(Integer t1) {
+                                    return "last group: " + t1;
+                                }
 
-                    });
+                            });
                 }
             }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 2dcb84dc8f..65d7854a2f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -31,6 +31,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
+import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
@@ -334,26 +335,31 @@ public void testTimeoutSelectorWithTimeoutAndOnNextRaceCondition() throws Interr
             public Observable call(Integer t1) {
                 if (t1 == 1) {
                     // Force "unsubscribe" run on another thread
-                    return Observable.create(new OnSubscribe(){
+                    return Observable.create(new OnSubscribe() {
                         @Override
                         public void call(Subscriber subscriber) {
-                            subscriber.add(Subscriptions.create(new Action0(){
+                            subscriber.add(Subscriptions.create(new Action0() {
                                 @Override
                                 public void call() {
                                     try {
                                         // emulate "unsubscribe" is busy and finishes after timeout.onNext(1)
                                         timeoutEmittedOne.await();
                                     } catch (InterruptedException e) {
+                                        // if we are interrupted then we complete (as this can happen when unsubscribed)
+                                        observerCompleted.countDown();
                                         e.printStackTrace();
                                     }
-                                }}));
+                                }
+                            }));
                             // force the timeout message be sent after observer.onNext(2)
                             try {
                                 observerReceivedTwo.await();
                             } catch (InterruptedException e) {
+                                // if we are interrupted then we complete (as this can happen when unsubscribed)
+                                observerCompleted.countDown();
                                 e.printStackTrace();
                             }
-                            if(!subscriber.isUnsubscribed()) {
+                            if (!subscriber.isUnsubscribed()) {
                                 subscriber.onNext(1);
                                 timeoutEmittedOne.countDown();
                             }
@@ -386,12 +392,14 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
 
         }).when(o).onCompleted();
 
+        final TestSubscriber ts = new TestSubscriber(o);
+
         new Thread(new Runnable() {
 
             @Override
             public void run() {
                 PublishSubject source = PublishSubject.create();
-                source.timeout(timeoutFunc, Observable.from(3)).subscribe(o);
+                source.timeout(timeoutFunc, Observable.from(3)).subscribe(ts);
                 source.onNext(1); // start timeout
                 source.onNext(2); // disable timeout
                 try {

From 4002bfd96600aa1fb61defbeb5d79030a30e2c13 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 13 Feb 2014 19:34:34 -0800
Subject: [PATCH 397/441] 0.17.0-RC1-SNAPSHOT

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 40da016b78..0b9225fbe4 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-SNAPSHOT
+version=0.17.0-RC1-SNAPSHOT

From 0000b2ceeacfe848e36e5316291e3936ef692349 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Fri, 14 Feb 2014 13:25:47 +0800
Subject: [PATCH 398/441] Add timeout to CoundDownLatch, ignore
 InterruptException and fix the test to be consistent with the new subscribeOn

---
 .../OperatorTimeoutWithSelectorTest.java      | 68 ++++++++++++-------
 1 file changed, 42 insertions(+), 26 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 65d7854a2f..709a82caa3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -15,12 +15,20 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -30,6 +38,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Scheduler;
 import rx.Subscriber;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
@@ -329,6 +338,8 @@ public void testTimeoutSelectorWithTimeoutAndOnNextRaceCondition() throws Interr
         final CountDownLatch observerReceivedTwo = new CountDownLatch(1);
         final CountDownLatch timeoutEmittedOne = new CountDownLatch(1);
         final CountDownLatch observerCompleted = new CountDownLatch(1);
+        final CountDownLatch enteredTimeoutOne = new CountDownLatch(1);
+        final AtomicBoolean latchTimeout = new AtomicBoolean(false);
 
         final Func1> timeoutFunc = new Func1>() {
             @Override
@@ -338,31 +349,23 @@ public Observable call(Integer t1) {
                     return Observable.create(new OnSubscribe() {
                         @Override
                         public void call(Subscriber subscriber) {
-                            subscriber.add(Subscriptions.create(new Action0() {
-                                @Override
-                                public void call() {
-                                    try {
-                                        // emulate "unsubscribe" is busy and finishes after timeout.onNext(1)
-                                        timeoutEmittedOne.await();
-                                    } catch (InterruptedException e) {
-                                        // if we are interrupted then we complete (as this can happen when unsubscribed)
-                                        observerCompleted.countDown();
-                                        e.printStackTrace();
+                            enteredTimeoutOne.countDown();
+                            // force the timeout message be sent after observer.onNext(2)
+                            while (true) {
+                                try {
+                                    if (!observerReceivedTwo.await(30, TimeUnit.SECONDS)) {
+                                        // CountDownLatch timeout
+                                        // There should be something wrong
+                                        latchTimeout.set(true);
                                     }
+                                    break;
+                                } catch (InterruptedException e) {
+                                    // Since we just want to emulate a busy method,
+                                    // we ignore the interrupt signal from Scheduler.
                                 }
-                            }));
-                            // force the timeout message be sent after observer.onNext(2)
-                            try {
-                                observerReceivedTwo.await();
-                            } catch (InterruptedException e) {
-                                // if we are interrupted then we complete (as this can happen when unsubscribed)
-                                observerCompleted.countDown();
-                                e.printStackTrace();
-                            }
-                            if (!subscriber.isUnsubscribed()) {
-                                subscriber.onNext(1);
-                                timeoutEmittedOne.countDown();
                             }
+                            subscriber.onNext(1);
+                            timeoutEmittedOne.countDown();
                         }
                     }).subscribeOn(Schedulers.newThread());
                 } else {
@@ -401,9 +404,18 @@ public void run() {
                 PublishSubject source = PublishSubject.create();
                 source.timeout(timeoutFunc, Observable.from(3)).subscribe(ts);
                 source.onNext(1); // start timeout
+                try {
+                    if(!enteredTimeoutOne.await(30, TimeUnit.SECONDS)) {
+                        latchTimeout.set(true);
+                    }
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
                 source.onNext(2); // disable timeout
                 try {
-                    timeoutEmittedOne.await();
+                    if(!timeoutEmittedOne.await(30, TimeUnit.SECONDS)) {
+                        latchTimeout.set(true);
+                    }
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
@@ -412,7 +424,11 @@ public void run() {
 
         }).start();
 
-        observerCompleted.await();
+        if(!observerCompleted.await(30, TimeUnit.SECONDS)) {
+            latchTimeout.set(true);
+        }
+
+        assertFalse("CoundDownLatch timeout", latchTimeout.get());
 
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);

From c57049c727506a578cd2d08bbf5b502dbdc007c1 Mon Sep 17 00:00:00 2001
From: Dave Moten 
Date: Fri, 14 Feb 2014 22:33:20 +1100
Subject: [PATCH 399/441] Update CompositeSubscriptionTest.java

Fix apparent typo, unsubscription of s2 was not checked and should have been.
---
 .../test/java/rx/subscriptions/CompositeSubscriptionTest.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index 99782f6f0e..ee2df6485b 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -238,7 +238,7 @@ public void testClear() {
         s.clear();
 
         assertTrue(s1.isUnsubscribed());
-        assertTrue(s1.isUnsubscribed());
+        assertTrue(s2.isUnsubscribed());
         assertFalse(s.isUnsubscribed());
 
         BooleanSubscription s3 = new BooleanSubscription();

From 1e6224d8934847fe4a625bf2888873e5d865444c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 14 Feb 2014 12:01:12 -0800
Subject: [PATCH 400/441] Revert to 1.8 as 1.10 is causing the build to fail

... complicated build server issues ... apparently isn't going to be resolved until Gradle 1.12.
---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 8368385b1b..19fa1710c4 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-all.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.8-all.zip

From 4264229d6720dcaf69e5f82926699cb209b012d3 Mon Sep 17 00:00:00 2001
From: Pyry Jahkola 
Date: Fri, 14 Feb 2014 20:21:36 +0000
Subject: [PATCH 401/441] Correct synchronization guard in groupByUntil

Can't see how `synchronized (key) { ... }` could have been correct here; `key` will hardly ever be the same instance for different invocations of `keySelector`, and the comment on line 73 clearly states `gate` to be the guard for `map`.
---
 .../src/main/java/rx/operators/OperationGroupByUntil.java       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index ab93b52015..c6bde5ff48 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -102,7 +102,7 @@ public void onNext(TSource args) {
 
             GroupSubject g;
             boolean newGroup = false;
-            synchronized (key) {
+            synchronized (gate) {
                 g = map.get(key);
                 if (g == null) {
                     g = create(key);

From df66fa199ece86374e14ac64adf71b3158097d71 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 14 Feb 2014 12:40:15 -0800
Subject: [PATCH 402/441] Scheduler.scheduleRecursive

Make recursive scheduling a first-class citizen without needing to refer to "this" which doesn't work inside lambdas (Java8/Scala/etc).

        Schedulers.newThread().scheduleRecursive(new Action1() {
            @Override
            public void call(Recurse r) {
                System.out.println("do stuff on thread: " + Thread.currentThread() + " Time: " + System.nanoTime());
                r.schedule(100, TimeUnit.MILLISECONDS);
            }
        });
---
 rxjava-core/src/main/java/rx/Scheduler.java | 51 +++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index fd93a92972..29d5e70f99 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -94,6 +94,57 @@ public void call(Inner inner) {
         return schedule(recursiveAction, initialDelay, unit);
     }
 
+    public final Subscription scheduleRecursive(final Action1 action) {
+        return schedule(new Action1() {
+
+            @Override
+            public void call(Inner inner) {
+                action.call(new Recurse(inner, action));
+            }
+
+        });
+    }
+
+    public static final class Recurse {
+        final Action1 action;
+        final Inner inner;
+
+        private Recurse(Inner inner, Action1 action) {
+            this.inner = inner;
+            this.action = action;
+        }
+
+        /**
+         * Schedule the current function for execution immediately.
+         */
+        public final void schedule() {
+            final Recurse self = this;
+            inner.schedule(new Action1() {
+
+                @Override
+                public void call(Inner _inner) {
+                    action.call(self);
+                }
+
+            });
+        }
+
+        /**
+         * Schedule the current function for execution in the future.
+         */
+        public final void schedule(long delay, TimeUnit unit) {
+            final Recurse self = this;
+            inner.schedule(new Action1() {
+
+                @Override
+                public void call(Inner _inner) {
+                    action.call(self);
+                }
+
+            }, delay, unit);
+        }
+    }
+
     public abstract static class Inner implements Subscription {
 
         /**

From 695f0b4d1ee0f94c0b8f3829aeaf6c795878b804 Mon Sep 17 00:00:00 2001
From: Bob T Builder 
Date: Fri, 14 Feb 2014 21:28:43 +0000
Subject: [PATCH 403/441] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC1'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 0b9225fbe4..9231286756 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC1-SNAPSHOT
+version=0.17.0-RC1

From c10abf47ead03cd60e838f5785e7ec5c0c227094 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Fri, 14 Feb 2014 13:32:27 -0800
Subject: [PATCH 404/441] 0.17.0-RC2-SNAPSHOT

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 9231286756..67948d6fcd 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC1
+version=0.17.0-RC2-SNAPSHOT

From a7a0ee9445f1310ece931ecfc8788d4f935cea75 Mon Sep 17 00:00:00 2001
From: David Gross 
Date: Fri, 14 Feb 2014 14:41:24 -0800
Subject: [PATCH 405/441] fixing javadoc layout bugs

---
 rxjava-core/src/main/java/rx/Observable.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 8d825e9fb2..f8fdfdd9b1 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2382,7 +2382,7 @@ public final static > Observable min(Observab
     }
 
     /**
-     * Convert the current Observable into an Observable>.
+     * Convert the current {@code Observable} into an {@code Observable>}.
      * 
    
      * 
      * 
@@ -3403,7 +3403,7 @@ public final static  Observable zip(Ob
      * 
      * @see RxJava Wiki: reduce()
      * @see #reduce(Func2)
-     * @deprecated use #reduce(Func2)
+     * @deprecated use {@link #reduce(Func2)}
      */
     @Deprecated
     public final Observable aggregate(Func2 accumulator) {
@@ -3417,7 +3417,7 @@ public final Observable aggregate(Func2 accumulator) {
      * 
      * @see RxJava Wiki: reduce()
      * @see #reduce(Object, Func2)
-     * @deprecated use #reduce(Object, Func2)
+     * @deprecated use {@link #reduce(Object, Func2)}
      */
     @Deprecated
     public final  Observable aggregate(R initialValue, Func2 accumulator) {
@@ -4044,7 +4044,7 @@ public final Observable defaultIfEmpty(T defaultValue) {
      * 
    
      * 
      * 
    
-     * Note: the resulting Observable will immediately propagate any {@code onError} notification
+     * Note: the resulting Observable will immediately propagate any {@code onError} notification
      * from the source Observable.
      * 
      * @param 

From f98616d0bcbb62f324972404ba1bfe0248856e00 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Sat, 15 Feb 2014 22:36:04 +0800
Subject: [PATCH 406/441] Force ViewObservable be subscribed and unsubscribed
 in the UI thread

---
 .../rx/android/observables/ViewObservable.java     |  6 ++++++
 .../OperationObserveFromAndroidComponent.java      | 13 +++++++++++--
 .../rx/operators/OperatorCompoundButtonInput.java  | 14 +++++++++++++-
 .../java/rx/operators/OperatorEditTextInput.java   | 14 +++++++++++++-
 .../main/java/rx/operators/OperatorViewClick.java  | 14 +++++++++++++-
 5 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/ViewObservable.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/ViewObservable.java
index bb0832b590..6e31af051e 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/ViewObservable.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/ViewObservable.java
@@ -15,6 +15,7 @@
  */
 package rx.android.observables;
 
+import android.os.Looper;
 import android.view.View;
 import android.widget.CompoundButton;
 import android.widget.EditText;
@@ -37,5 +38,10 @@ public static Observable input(final CompoundButton button, final boole
         return Observable.create(new OperatorCompoundButtonInput(button, emitInitialValue));
     }
 
+    public static void assertUiThread() {
+        if (Looper.getMainLooper() != Looper.myLooper()) {
+            throw new IllegalStateException("Observers must subscribe from the main UI thread, but was " + Thread.currentThread());
+        }
+    }
 }
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
index 169c99e9af..f0dca7d2f9 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
@@ -18,9 +18,11 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.Scheduler.Inner;
 import rx.android.schedulers.AndroidSchedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Action1;
 import android.app.Activity;
 import android.os.Looper;
 import android.util.Log;
@@ -100,8 +102,15 @@ public void onNext(T args) {
                 @Override
                 public void call() {
                     log("unsubscribing from source sequence");
-                    releaseReferences();
-                    sourceSub.unsubscribe();
+                    AndroidSchedulers.mainThread().schedule(new Action1() {
+
+                        @Override
+                        public void call(Inner t1) {
+                            releaseReferences();
+                            sourceSub.unsubscribe();
+                        }
+
+                    });
                 }
             });
         }
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
index c945bc039a..f409410e4c 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
@@ -23,8 +23,12 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.Scheduler.Inner;
+import rx.android.observables.ViewObservable;
+import rx.android.schedulers.AndroidSchedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Action1;
 import android.view.View;
 import android.widget.CompoundButton;
 
@@ -39,6 +43,7 @@ public OperatorCompoundButtonInput(final CompoundButton button, final boolean em
 
     @Override
     public void call(final Subscriber observer) {
+        ViewObservable.assertUiThread();
         final CompositeOnCheckedChangeListener composite = CachedListeners.getFromViewOrCreate(button);
 
         final CompoundButton.OnCheckedChangeListener listener = new CompoundButton.OnCheckedChangeListener() {
@@ -51,7 +56,14 @@ public void onCheckedChanged(final CompoundButton button, final boolean checked)
         final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
             public void call() {
-                composite.removeOnCheckedChangeListener(listener);
+                AndroidSchedulers.mainThread().schedule(new Action1() {
+
+                    @Override
+                    public void call(Inner t1) {
+                        composite.removeOnCheckedChangeListener(listener);
+                    }
+
+                });
             }
         });
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
index 94e516bf3e..896fe3c7e5 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
@@ -18,8 +18,12 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.Scheduler.Inner;
+import rx.android.observables.ViewObservable;
+import rx.android.schedulers.AndroidSchedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Action1;
 import android.text.Editable;
 import android.text.TextWatcher;
 import android.widget.EditText;
@@ -35,6 +39,7 @@ public OperatorEditTextInput(final EditText input, final boolean emitInitialValu
 
     @Override
     public void call(final Subscriber observer) {
+        ViewObservable.assertUiThread();
         final TextWatcher watcher = new SimpleTextWatcher() {
             @Override
             public void afterTextChanged(final Editable editable) {
@@ -45,7 +50,14 @@ public void afterTextChanged(final Editable editable) {
         final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
             public void call() {
-                input.removeTextChangedListener(watcher);
+                AndroidSchedulers.mainThread().schedule(new Action1() {
+
+                    @Override
+                    public void call(Inner t1) {
+                        input.removeTextChangedListener(watcher);
+                    }
+
+                });
             }
         });
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
index 32ed2de185..b6ea615a13 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
@@ -21,10 +21,14 @@
 import java.util.WeakHashMap;
 
 import rx.Observable;
+import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.android.observables.ViewObservable;
+import rx.android.schedulers.AndroidSchedulers;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
+import rx.util.functions.Action1;
 import android.view.View;
 
 public final class OperatorViewClick implements Observable.OnSubscribe {
@@ -38,6 +42,7 @@ public OperatorViewClick(final View view, final boolean emitInitialValue) {
 
     @Override
     public void call(final Subscriber observer) {
+        ViewObservable.assertUiThread();
         final CompositeOnClickListener composite = CachedListeners.getFromViewOrCreate(view);
 
         final View.OnClickListener listener = new View.OnClickListener() {
@@ -50,7 +55,14 @@ public void onClick(final View clicked) {
         final Subscription subscription = Subscriptions.create(new Action0() {
             @Override
             public void call() {
-                composite.removeOnClickListener(listener);
+                AndroidSchedulers.mainThread().schedule(new Action1() {
+
+                    @Override
+                    public void call(Inner t1) {
+                        composite.removeOnClickListener(listener);
+                    }
+
+                });
             }
         });
 

From 7ffb0ef4d56a0ebb95eec41ca751eaad50719b99 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Mon, 17 Feb 2014 01:01:50 -0800
Subject: [PATCH 407/441] Fixed an issue with the from(Reader) added a bunch of
 unit tests.

---
 .../java/rx/observables/StringObservable.java | 102 +++++++++++++++++-
 .../rx/observables/StringObservableTest.java  |  30 ++++++
 2 files changed, 128 insertions(+), 4 deletions(-)

diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
index df96b64473..9e87ab50d7 100644
--- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
+++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
@@ -27,6 +27,7 @@
 import java.nio.charset.CoderResult;
 import java.nio.charset.CodingErrorAction;
 import java.util.Arrays;
+import java.util.Objects;
 import java.util.regex.Pattern;
 
 import rx.Observable;
@@ -37,10 +38,28 @@
 import rx.util.functions.Func2;
 
 public class StringObservable {
+    /**
+     * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
+     * {@link byte[]}s
+     * 
+     * @param i
+     *            Source {@link InputStream}
+     * @return
+     */
     public static Observable from(final InputStream i) {
         return from(i, 8 * 1024);
     }
 
+    /**
+     * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
+     * {@link byte[]}s
+     * 
+     * @param i
+     *            Source {@link InputStream}
+     * @param size
+     *            internal buffer size
+     * @return
+     */
     public static Observable from(final InputStream i, final int size) {
         return Observable.create(new OnSubscribe() {
             @Override
@@ -65,10 +84,28 @@ public void call(Subscriber o) {
         });
     }
 
+    /**
+     * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
+     * {@link String}s
+     * 
+     * @param i
+     *            Source {@link Reader}
+     * @return
+     */
     public static Observable from(final Reader i) {
         return from(i, 8 * 1024);
     }
 
+    /**
+     * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
+     * {@link String}s
+     * 
+     * @param i
+     *            Source {@link Reader}
+     * @param size
+     *            internal buffer size
+     * @return
+     */
     public static Observable from(final Reader i, final int size) {
         return Observable.create(new OnSubscribe() {
             @Override
@@ -80,7 +117,7 @@ public void call(Subscriber o) {
                     int n = 0;
                     n = i.read(buffer);
                     while (n != -1 && !o.isUnsubscribed()) {
-                        o.onNext(new String(buffer));
+                        o.onNext(new String(buffer, 0, n));
                         n = i.read(buffer);
                     }
                 } catch (IOException e) {
@@ -119,7 +156,7 @@ public static Observable decode(Observable src, Charset charset)
 
     /**
      * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
-     * and where handles when a multibyte character spans two chunks.
+     * and where it handles when a multibyte character spans two chunks.
      * This method allows for more control over how malformed and unmappable characters are handled.
      * 
      * @param src
@@ -151,6 +188,9 @@ public void onNext(byte[] bytes) {
                     }
 
                     public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
+                        if (o.isUnsubscribed())
+                            return false;
+
                         ByteBuffer bb;
                         if (last != null) {
                             if (next != null) {
@@ -270,8 +310,10 @@ public String call(String a, String b) {
     /**
      * Rechunks the strings based on a regex pattern and works on infinite stream.
      * 
-     * resplit(["boo:an", "d:foo"], ":") --> ["boo", "and", "foo"]
-     * resplit(["boo:an", "d:foo"], "o") --> ["b", "", ":and:f", "", ""]
+     * 
    +     * split(["boo:an", "d:foo"], ":") --> ["boo", "and", "foo"]
+     * split(["boo:an", "d:foo"], "o") --> ["b", "", ":and:f", "", ""]
+     * 
    
      * 
      * See {@link Pattern}
      * 
@@ -399,4 +441,56 @@ public void onNext(Object t) {
             }
         });
     }
+
+    public final static class Line {
+        private final int number;
+        private final String text;
+
+        public Line(int number, String text) {
+            this.number = number;
+            this.text = text;
+        }
+
+        public int getNumber() {
+            return number;
+        }
+
+        public String getText() {
+            return text;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(number, text);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (!(obj instanceof Line))
+                return false;
+            return Objects.equals(number, ((Line) obj).number) && Objects.equals(text, ((Line) obj).text);
+        }
+
+        @Override
+        public String toString() {
+            return number + ":" + text;
+        }
+    }
+
+    /**
+     * Splits the {@link Observable} of Strings by lines and numbers them (zero based index)
+     * 
+     * @param source
+     * @return
+     */
+    public static Observable byLine(Observable source) {
+        return split(source, System.getProperty("line.separator")).map(new Func1() {
+            int lineNumber = 0;
+
+            @Override
+            public Line call(String text) {
+                return new Line(lineNumber++, text);
+            }
+        });
+    }
 }
diff --git a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
index 8b3577b601..01dcc8f435 100644
--- a/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
+++ b/rxjava-contrib/rxjava-string/src/test/java/rx/observables/StringObservableTest.java
@@ -19,16 +19,23 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.NotSerializableException;
+import java.io.StringReader;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.MalformedInputException;
 import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.Assert;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
+import rx.observables.StringObservable.Line;
 import rx.observers.TestObserver;
 import rx.util.AssertObservable;
 
@@ -221,4 +228,27 @@ public void testJoinThrows() {
         verify(observer, never()).onCompleted();
         verify(observer, times(1)).onError(any(Throwable.class));
     }
+
+    @Test
+    public void testFromInputStream() {
+        final byte[] inBytes = "test".getBytes();
+        final byte[] outBytes = StringObservable.from(new ByteArrayInputStream(inBytes)).toBlockingObservable().single();
+        assertNotSame(inBytes, outBytes);
+        assertArrayEquals(inBytes, outBytes);
+    }
+
+    @Test
+    public void testFromReader() {
+        final String inStr = "test";
+        final String outStr = StringObservable.from(new StringReader(inStr)).toBlockingObservable().single();
+        assertNotSame(inStr, outStr);
+        assertEquals(inStr, outStr);
+    }
+
+    @Test
+    public void testByLine() {
+        List lines = StringObservable.byLine(Observable.from(Arrays.asList("qwer", "\nasdf\n", "zx", "cv"))).toList().toBlockingObservable().single();
+
+        assertEquals(Arrays.asList(new Line(0, "qwer"), new Line(1, "asdf"), new Line(2, "zxcv")), lines);
+    }
 }

From 2f3968dbfda2dd88a52a5737931e4df606ba46d0 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 10:25:09 -0800
Subject: [PATCH 408/441] Remove Bad Filter Logic

This code was accidentally committed during exploration of groupBy/subscribeOn.
---
 .../src/main/java/rx/operators/OperatorFilter.java | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index 41b749dc75..a6e8850f2b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -52,20 +52,6 @@ public void onNext(T value) {
                 try {
                     if (predicate.call(value)) {
                         child.onNext(value);
-                    } else {
-                        /*
-                         * Special casing of GroupedObservable since GroupedObservable ***MUST*** be subscribed to
-                         * otherwise it will block the GroupBy operator. 
-                         * 
-                         * See https://github.com/Netflix/RxJava/issues/844
-                         */
-                        if (value instanceof GroupedObservable) {
-                            System.out.println("value is GroupedObservable");
-                            @SuppressWarnings("rawtypes")
-                            GroupedObservable go = (GroupedObservable) value;
-                            System.out.println("********* unsubscribe from go");
-                            go.take(0).subscribe();
-                        }
                     }
                 } catch (Throwable ex) {
                     child.onError(ex);

From ac4aed1bdb7a67a3fae70c41549aef7e0d4fc6d1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 10:24:15 -0800
Subject: [PATCH 409/441] Revert Bounded ObserveOn

---
 rxjava-core/src/main/java/rx/Observable.java  |  22 +-
 .../java/rx/operators/OperatorObserveOn.java  | 231 ++-------
 .../operators/OperatorObserveOnBounded.java   | 330 +++++++++++++
 .../OperatorObserveOnPerformance.java         |  37 +-
 .../OperatorObserveOnBoundedTest.java         | 461 ++++++++++++++++++
 .../rx/operators/OperatorObserveOnTest.java   | 103 ----
 6 files changed, 853 insertions(+), 331 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index f8fdfdd9b1..82e65c46f5 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -69,6 +69,7 @@
 import rx.operators.OperationReplay;
 import rx.operators.OperationRetry;
 import rx.operators.OperationSample;
+import rx.operators.OperatorObserveOnBounded;
 import rx.operators.OperatorScan;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSingle;
@@ -5148,7 +5149,7 @@ public final  ConnectableObservable multicast(Subject
      * 
      * 
@@ -5162,25 +5163,6 @@ public final Observable observeOn(Scheduler scheduler) {
         return lift(new OperatorObserveOn(scheduler));
     }
 
-    /**
-     * Move notifications to the specified {@link Scheduler} asynchronously with a buffer of a specified size.
-     * 
    
-     * 
-     * 
    
-     * If the buffer fills to its maximum size...
-     * 
-     * @param scheduler
-     *            the {@link Scheduler} to notify {@link Observer}s on
-     * @param bufferSize
-     *            that will be rounded up to the next power of 2
-     * @return the source Observable modified so that its {@link Observer}s are notified on the specified
-     *         {@link Scheduler}
-     * @see RxJava Wiki: observeOn()
-     */
-    public final Observable observeOn(Scheduler scheduler, int bufferSize) {
-        return lift(new OperatorObserveOn(scheduler, bufferSize));
-    }
-    
     /**
      * Filters the items emitted by an Observable, only emitting those of the specified type.
      * 
    
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 5fc9ed75e1..c963bf3783 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import java.util.concurrent.Semaphore;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Observable.Operator;
@@ -23,61 +23,23 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.schedulers.ImmediateScheduler;
-import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
 /**
- * Delivers events on the specified Scheduler.
- * 
    
- * This provides backpressure by blocking the incoming onNext when there is already one in the queue.
- * 
    
- * This means that at any given time the max number of "onNext" in flight is 3:
- * -> 1 being delivered on the Scheduler
- * -> 1 in the queue waiting for the Scheduler
- * -> 1 blocking on the queue waiting to deliver it
- * 
- * I have chosen to allow 1 in the queue rather than using an Exchanger style process so that the Scheduler
- * can loop and have something to do each time around to optimize for avoiding rescheduling when it
- * can instead just loop. I'm avoiding having the Scheduler thread ever block as it could be an event-loop
- * thus if the queue is empty it exits and next time something is added it will reschedule.
+ * Delivers events on the specified Scheduler asynchronously via an unbounded buffer.
  * 
  * 
  */
 public class OperatorObserveOn implements Operator {
 
     private final Scheduler scheduler;
-    private final int bufferSize;
 
     /**
-     * 
      * @param scheduler
-     * @param bufferSize
-     *            that will be rounded up to the next power of 2
      */
-    public OperatorObserveOn(Scheduler scheduler, int bufferSize) {
-        this.scheduler = scheduler;
-        this.bufferSize = roundToNextPowerOfTwoIfNecessary(bufferSize);
-    }
-
     public OperatorObserveOn(Scheduler scheduler) {
-        this(scheduler, 1);
-    }
-
-    private static int roundToNextPowerOfTwoIfNecessary(int num) {
-        if ((num & -num) == num) {
-            return num;
-        } else {
-            int result = 1;
-            while (num != 0)
-            {
-                num >>= 1;
-                result <<= 1;
-            }
-            return result;
-        }
+        this.scheduler = scheduler;
     }
 
     @Override
@@ -88,19 +50,19 @@ public Subscriber call(Subscriber child) {
         } else if (scheduler instanceof TrampolineScheduler) {
             // avoid overhead, execute directly
             return child;
-        } else if (scheduler instanceof TestScheduler) {
-            // this one will deadlock as it is single-threaded and won't run the scheduled
-            // work until it manually advances, which it won't be able to do as it will block
-            return child;
         } else {
             return new ObserveOnSubscriber(child);
         }
     }
 
-    private static Object NULL_SENTINEL = new Object();
-    private static Object COMPLETE_SENTINEL = new Object();
+    private static class Sentinel {
 
-    private static class ErrorSentinel {
+    }
+
+    private static Sentinel NULL_SENTINEL = new Sentinel();
+    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
+
+    private static class ErrorSentinel extends Sentinel {
         final Throwable e;
 
         ErrorSentinel(Throwable e) {
@@ -113,7 +75,7 @@ private class ObserveOnSubscriber extends Subscriber {
         final Subscriber observer;
         private volatile Scheduler.Inner recursiveScheduler;
 
-        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue(bufferSize);
+        private final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue();
         final AtomicLong counter = new AtomicLong(0);
 
         public ObserveOnSubscriber(Subscriber observer) {
@@ -123,62 +85,29 @@ public ObserveOnSubscriber(Subscriber observer) {
 
         @Override
         public void onNext(final T t) {
-            try {
-                // we want to block for natural back-pressure
-                // so that the producer waits for each value to be consumed
-                if (t == null) {
-                    queue.addBlocking(NULL_SENTINEL);
-                } else {
-                    queue.addBlocking(t);
-                }
-                schedule();
-            } catch (InterruptedException e) {
-                if (!isUnsubscribed()) {
-                    onError(e);
-                }
+            if (t == null) {
+                queue.offer(NULL_SENTINEL);
+            } else {
+                queue.offer(t);
             }
+            schedule();
         }
 
         @Override
         public void onCompleted() {
-            try {
-                // we want to block for natural back-pressure
-                // so that the producer waits for each value to be consumed
-                queue.addBlocking(COMPLETE_SENTINEL);
-                schedule();
-            } catch (InterruptedException e) {
-                onError(e);
-            }
+            queue.offer(COMPLETE_SENTINEL);
+            schedule();
         }
 
         @Override
         public void onError(final Throwable e) {
-            try {
-                // we want to block for natural back-pressure
-                // so that the producer waits for each value to be consumed
-                queue.addBlocking(new ErrorSentinel(e));
-                schedule();
-            } catch (InterruptedException e2) {
-                // call directly if we can't schedule
-                observer.onError(e2);
-            }
+            queue.offer(new ErrorSentinel(e));
+            schedule();
         }
 
         protected void schedule() {
             if (counter.getAndIncrement() == 0) {
                 if (recursiveScheduler == null) {
-                    // first time through, register a Subscription
-                    // that can interrupt this thread
-                    add(Subscriptions.create(new Action0() {
-
-                        @Override
-                        public void call() {
-                            // we have to interrupt the parent thread because
-                            // it can be blocked on queue.put
-                            queue.interrupt();
-                        }
-
-                    }));
                     add(scheduler.schedule(new Action1() {
 
                         @Override
@@ -206,12 +135,14 @@ private void pollQueue() {
             do {
                 Object v = queue.poll();
                 if (v != null) {
-                    if (v == NULL_SENTINEL) {
-                        observer.onNext(null);
-                    } else if (v == COMPLETE_SENTINEL) {
-                        observer.onCompleted();
-                    } else if (v instanceof ErrorSentinel) {
-                        observer.onError(((ErrorSentinel) v).e);
+                    if (v instanceof Sentinel) {
+                        if (v == NULL_SENTINEL) {
+                            observer.onNext(null);
+                        } else if (v == COMPLETE_SENTINEL) {
+                            observer.onCompleted();
+                        } else if (v instanceof ErrorSentinel) {
+                            observer.onError(((ErrorSentinel) v).e);
+                        }
                     } else {
                         observer.onNext((T) v);
                     }
@@ -221,110 +152,4 @@ private void pollQueue() {
 
     }
 
-    /**
-     * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
-     * 
-     * This supports an interrupt() being called externally rather than needing to interrupt the thread. This allows
-     * unsubscribe behavior when this queue is being used.
-     * 
-     * @param 
-     */
-    private static class InterruptibleBlockingQueue {
-
-        private final Semaphore semaphore;
-        private volatile boolean interrupted = false;
-
-        private final E[] buffer;
-
-        private AtomicLong tail = new AtomicLong();
-        private AtomicLong head = new AtomicLong();
-        private final int capacity;
-        private final int mask;
-
-        @SuppressWarnings("unchecked")
-        public InterruptibleBlockingQueue(final int size) {
-            this.semaphore = new Semaphore(size);
-            this.capacity = size;
-            this.mask = size - 1;
-            buffer = (E[]) new Object[size];
-        }
-
-        /**
-         * Used to unsubscribe and interrupt the producer if blocked in put()
-         */
-        public void interrupt() {
-            interrupted = true;
-            semaphore.release();
-        }
-
-        public void addBlocking(final E e) throws InterruptedException {
-            if (interrupted) {
-                throw new InterruptedException("Interrupted by Unsubscribe");
-            }
-            semaphore.acquire();
-            if (interrupted) {
-                throw new InterruptedException("Interrupted by Unsubscribe");
-            }
-            if (e == null) {
-                throw new IllegalArgumentException("Can not put null");
-            }
-
-            if (offer(e)) {
-                return;
-            } else {
-                throw new IllegalStateException("Queue is full");
-            }
-        }
-
-        private boolean offer(final E e) {
-            final long _t = tail.get();
-            if (_t - head.get() == capacity) {
-                // queue is full
-                return false;
-            }
-            int index = (int) (_t & mask);
-            buffer[index] = e;
-            // move the tail forward
-            tail.lazySet(_t + 1);
-
-            return true;
-        }
-
-        public E poll() {
-            if (interrupted) {
-                return null;
-            }
-            final long _h = head.get();
-            if (tail.get() == _h) {
-                // nothing available
-                return null;
-            }
-            int index = (int) (_h & mask);
-
-            // fetch the item
-            E v = buffer[index];
-            // allow GC to happen
-            buffer[index] = null;
-            // increment and signal we're done
-            head.lazySet(_h + 1);
-            if (v != null) {
-                semaphore.release();
-            }
-            return v;
-        }
-
-        public int size()
-        {
-            int size;
-            do
-            {
-                final long currentHead = head.get();
-                final long currentTail = tail.get();
-                size = (int) (currentTail - currentHead);
-            } while (size > buffer.length);
-
-            return size;
-        }
-
-    }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
new file mode 100644
index 0000000000..740f8fdad4
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
@@ -0,0 +1,330 @@
+/**
+ * Copyright 2014 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 java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicLong;
+
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.schedulers.ImmediateScheduler;
+import rx.schedulers.TestScheduler;
+import rx.schedulers.TrampolineScheduler;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Delivers events on the specified Scheduler.
+ * 
    
+ * This provides backpressure by blocking the incoming onNext when there is already one in the queue.
+ * 
    
+ * This means that at any given time the max number of "onNext" in flight is 3:
+ * -> 1 being delivered on the Scheduler
+ * -> 1 in the queue waiting for the Scheduler
+ * -> 1 blocking on the queue waiting to deliver it
+ * 
+ * I have chosen to allow 1 in the queue rather than using an Exchanger style process so that the Scheduler
+ * can loop and have something to do each time around to optimize for avoiding rescheduling when it
+ * can instead just loop. I'm avoiding having the Scheduler thread ever block as it could be an event-loop
+ * thus if the queue is empty it exits and next time something is added it will reschedule.
+ * 
+ * 
+ */
+public class OperatorObserveOnBounded implements Operator {
+
+    private final Scheduler scheduler;
+    private final int bufferSize;
+
+    /**
+     * 
+     * @param scheduler
+     * @param bufferSize
+     *            that will be rounded up to the next power of 2
+     */
+    public OperatorObserveOnBounded(Scheduler scheduler, int bufferSize) {
+        this.scheduler = scheduler;
+        this.bufferSize = roundToNextPowerOfTwoIfNecessary(bufferSize);
+    }
+
+    public OperatorObserveOnBounded(Scheduler scheduler) {
+        this(scheduler, 1);
+    }
+
+    private static int roundToNextPowerOfTwoIfNecessary(int num) {
+        if ((num & -num) == num) {
+            return num;
+        } else {
+            int result = 1;
+            while (num != 0)
+            {
+                num >>= 1;
+                result <<= 1;
+            }
+            return result;
+        }
+    }
+
+    @Override
+    public Subscriber call(Subscriber child) {
+        if (scheduler instanceof ImmediateScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else if (scheduler instanceof TrampolineScheduler) {
+            // avoid overhead, execute directly
+            return child;
+        } else if (scheduler instanceof TestScheduler) {
+            // this one will deadlock as it is single-threaded and won't run the scheduled
+            // work until it manually advances, which it won't be able to do as it will block
+            return child;
+        } else {
+            return new ObserveOnSubscriber(child);
+        }
+    }
+
+    private static Object NULL_SENTINEL = new Object();
+    private static Object COMPLETE_SENTINEL = new Object();
+
+    private static class ErrorSentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
+
+    /** Observe through individual queue per observer. */
+    private class ObserveOnSubscriber extends Subscriber {
+        final Subscriber observer;
+        private volatile Scheduler.Inner recursiveScheduler;
+
+        private final InterruptibleBlockingQueue queue = new InterruptibleBlockingQueue(bufferSize);
+        final AtomicLong counter = new AtomicLong(0);
+
+        public ObserveOnSubscriber(Subscriber observer) {
+            super(observer);
+            this.observer = observer;
+        }
+
+        @Override
+        public void onNext(final T t) {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                if (t == null) {
+                    queue.addBlocking(NULL_SENTINEL);
+                } else {
+                    queue.addBlocking(t);
+                }
+                schedule();
+            } catch (InterruptedException e) {
+                if (!isUnsubscribed()) {
+                    onError(e);
+                }
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                queue.addBlocking(COMPLETE_SENTINEL);
+                schedule();
+            } catch (InterruptedException e) {
+                onError(e);
+            }
+        }
+
+        @Override
+        public void onError(final Throwable e) {
+            try {
+                // we want to block for natural back-pressure
+                // so that the producer waits for each value to be consumed
+                queue.addBlocking(new ErrorSentinel(e));
+                schedule();
+            } catch (InterruptedException e2) {
+                // call directly if we can't schedule
+                observer.onError(e2);
+            }
+        }
+
+        protected void schedule() {
+            if (counter.getAndIncrement() == 0) {
+                if (recursiveScheduler == null) {
+                    // first time through, register a Subscription
+                    // that can interrupt this thread
+                    add(Subscriptions.create(new Action0() {
+
+                        @Override
+                        public void call() {
+                            // we have to interrupt the parent thread because
+                            // it can be blocked on queue.put
+                            queue.interrupt();
+                        }
+
+                    }));
+                    add(scheduler.schedule(new Action1() {
+
+                        @Override
+                        public void call(Inner inner) {
+                            recursiveScheduler = inner;
+                            pollQueue();
+                        }
+
+                    }));
+                } else {
+                    recursiveScheduler.schedule(new Action1() {
+
+                        @Override
+                        public void call(Inner inner) {
+                            pollQueue();
+                        }
+
+                    });
+                }
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        private void pollQueue() {
+            do {
+                Object v = queue.poll();
+                if (v != null) {
+                    if (v == NULL_SENTINEL) {
+                        observer.onNext(null);
+                    } else if (v == COMPLETE_SENTINEL) {
+                        observer.onCompleted();
+                    } else if (v instanceof ErrorSentinel) {
+                        observer.onError(((ErrorSentinel) v).e);
+                    } else {
+                        observer.onNext((T) v);
+                    }
+                }
+            } while (counter.decrementAndGet() > 0);
+        }
+
+    }
+
+    /**
+     * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
+     * 
+     * This supports an interrupt() being called externally rather than needing to interrupt the thread. This allows
+     * unsubscribe behavior when this queue is being used.
+     * 
+     * @param 
+     */
+    private static class InterruptibleBlockingQueue {
+
+        private final Semaphore semaphore;
+        private volatile boolean interrupted = false;
+
+        private final E[] buffer;
+
+        private AtomicLong tail = new AtomicLong();
+        private AtomicLong head = new AtomicLong();
+        private final int capacity;
+        private final int mask;
+
+        @SuppressWarnings("unchecked")
+        public InterruptibleBlockingQueue(final int size) {
+            this.semaphore = new Semaphore(size);
+            this.capacity = size;
+            this.mask = size - 1;
+            buffer = (E[]) new Object[size];
+        }
+
+        /**
+         * Used to unsubscribe and interrupt the producer if blocked in put()
+         */
+        public void interrupt() {
+            interrupted = true;
+            semaphore.release();
+        }
+
+        public void addBlocking(final E e) throws InterruptedException {
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            semaphore.acquire();
+            if (interrupted) {
+                throw new InterruptedException("Interrupted by Unsubscribe");
+            }
+            if (e == null) {
+                throw new IllegalArgumentException("Can not put null");
+            }
+
+            if (offer(e)) {
+                return;
+            } else {
+                throw new IllegalStateException("Queue is full");
+            }
+        }
+
+        private boolean offer(final E e) {
+            final long _t = tail.get();
+            if (_t - head.get() == capacity) {
+                // queue is full
+                return false;
+            }
+            int index = (int) (_t & mask);
+            buffer[index] = e;
+            // move the tail forward
+            tail.lazySet(_t + 1);
+
+            return true;
+        }
+
+        public E poll() {
+            if (interrupted) {
+                return null;
+            }
+            final long _h = head.get();
+            if (tail.get() == _h) {
+                // nothing available
+                return null;
+            }
+            int index = (int) (_h & mask);
+
+            // fetch the item
+            E v = buffer[index];
+            // allow GC to happen
+            buffer[index] = null;
+            // increment and signal we're done
+            head.lazySet(_h + 1);
+            if (v != null) {
+                semaphore.release();
+            }
+            return v;
+        }
+
+        public int size()
+        {
+            int size;
+            do
+            {
+                final long currentHead = head.get();
+                final long currentTail = tail.get();
+                size = (int) (currentTail - currentHead);
+            } while (size > buffer.length);
+
+            return size;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
index f14b2a25b3..4a28e85d6d 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
@@ -22,7 +22,7 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeObserveOn();
+                    spt.timeObserveOnUnbounded();
                 }
             });
         } catch (Exception e) {
@@ -31,6 +31,35 @@ public void call() {
 
     }
 
+    /**
+     * Observable.from(1L).observeOn() using ImmediateScheduler
+     * 
+     * NOTE: Variance is high enough that there is obviously something else that needs to be done to make these benchmarks trustworthy.
+     * 
+     * --- version 0.17.1
+     * 
+     * Run: 10 - 69,444,444 ops/sec
+     * Run: 11 - 38,167,938 ops/sec
+     * Run: 12 - 41,841,004 ops/sec
+     * Run: 13 - 113,636,363 ops/sec
+     * Run: 14 - 38,759,689 ops/sec
+     * 
+     * --- version 0.16.1
+     * 
+     * Run: 10 - 42,735,042 ops/sec
+     * Run: 11 - 40,160,642 ops/sec
+     * Run: 12 - 63,694,267 ops/sec
+     * Run: 13 - 75,757,575 ops/sec
+     * Run: 14 - 43,290,043 ops/sec
+     * 
+     */
+    public long timeObserveOnUnbounded() {
+        Observable s = Observable.range(1, (int) reps).observeOn(Schedulers.immediate());
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        return o.sum;
+    }
+
     /**
      * Observable.from(1L).observeOn()
      * 
@@ -66,11 +95,9 @@ public void call() {
      * Run: 13 - 26,879,552 ops/sec
      * Run: 14 - 26,658,846 ops/sec
      * 
-     * 
      */
-    public long timeObserveOn() {
-
-        Observable s = Observable.range(1, (int) reps).observeOn(Schedulers.newThread(), 16);
+    public long timeObserveOnBounded() {
+        Observable s = Observable.range(1, (int) reps).lift(new OperatorObserveOnBounded(Schedulers.newThread(), 16));
         IntegerSumObserver o = new IntegerSumObserver();
         s.subscribe(o);
         return o.sum;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
new file mode 100644
index 0000000000..260ea3ae1b
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
@@ -0,0 +1,461 @@
+/**
+ * Copyright 2014 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 static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.schedulers.ImmediateScheduler;
+import rx.schedulers.Schedulers;
+import rx.schedulers.TestScheduler;
+import rx.schedulers.TrampolineScheduler;
+import rx.subscriptions.BooleanSubscription;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public class OperatorObserveOnBoundedTest {
+
+    /**
+     * This is testing a no-op path since it uses Schedulers.immediate() which will not do scheduling.
+     */
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testObserveOn() {
+        Observer observer = mock(Observer.class);
+        Observable.from(1, 2, 3).lift(new OperatorObserveOnBounded(Schedulers.immediate(), 1)).subscribe(observer);
+
+        verify(observer, times(1)).onNext(1);
+        verify(observer, times(1)).onNext(2);
+        verify(observer, times(1)).onNext(3);
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testOrdering() throws InterruptedException {
+        Observable obs = Observable.from("one", null, "two", "three", "four");
+
+        Observer observer = mock(Observer.class);
+
+        InOrder inOrder = inOrder(observer);
+
+        final CountDownLatch completedLatch = new CountDownLatch(1);
+        doAnswer(new Answer() {
+
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                completedLatch.countDown();
+                return null;
+            }
+        }).when(observer).onCompleted();
+
+        obs.lift(new OperatorObserveOnBounded(Schedulers.computation(), 1)).subscribe(observer);
+
+        if (!completedLatch.await(1000, TimeUnit.MILLISECONDS)) {
+            fail("timed out waiting");
+        }
+
+        inOrder.verify(observer, times(1)).onNext("one");
+        inOrder.verify(observer, times(1)).onNext(null);
+        inOrder.verify(observer, times(1)).onNext("two");
+        inOrder.verify(observer, times(1)).onNext("three");
+        inOrder.verify(observer, times(1)).onNext("four");
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testThreadName() throws InterruptedException {
+        System.out.println("Main Thread: " + Thread.currentThread().getName());
+        Observable obs = Observable.from("one", null, "two", "three", "four");
+
+        Observer observer = mock(Observer.class);
+        final String parentThreadName = Thread.currentThread().getName();
+
+        final CountDownLatch completedLatch = new CountDownLatch(1);
+
+        // assert subscribe is on main thread
+        obs = obs.doOnNext(new Action1() {
+
+            @Override
+            public void call(String s) {
+                String threadName = Thread.currentThread().getName();
+                System.out.println("Source ThreadName: " + threadName + "  Expected => " + parentThreadName);
+                assertEquals(parentThreadName, threadName);
+            }
+
+        });
+
+        // assert observe is on new thread
+        obs.lift(new OperatorObserveOnBounded(Schedulers.newThread(), 1)).doOnNext(new Action1() {
+
+            @Override
+            public void call(String t1) {
+                String threadName = Thread.currentThread().getName();
+                boolean correctThreadName = threadName.startsWith("RxNewThreadScheduler");
+                System.out.println("ObserveOn ThreadName: " + threadName + "  Correct => " + correctThreadName);
+                assertTrue(correctThreadName);
+            }
+
+        }).finallyDo(new Action0() {
+
+            @Override
+            public void call() {
+                completedLatch.countDown();
+
+            }
+        }).subscribe(observer);
+
+        if (!completedLatch.await(1000, TimeUnit.MILLISECONDS)) {
+            fail("timed out waiting");
+        }
+
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(5)).onNext(any(String.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void observeOnTheSameSchedulerTwice() {
+        Scheduler scheduler = Schedulers.immediate();
+
+        Observable o = Observable.from(1, 2, 3);
+        Observable o2 = o.lift(new OperatorObserveOnBounded(scheduler, 1));
+
+        @SuppressWarnings("unchecked")
+        Observer observer1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
+        Observer observer2 = mock(Observer.class);
+
+        InOrder inOrder1 = inOrder(observer1);
+        InOrder inOrder2 = inOrder(observer2);
+
+        o2.subscribe(observer1);
+        o2.subscribe(observer2);
+
+        inOrder1.verify(observer1, times(1)).onNext(1);
+        inOrder1.verify(observer1, times(1)).onNext(2);
+        inOrder1.verify(observer1, times(1)).onNext(3);
+        inOrder1.verify(observer1, times(1)).onCompleted();
+        verify(observer1, never()).onError(any(Throwable.class));
+        inOrder1.verifyNoMoreInteractions();
+
+        inOrder2.verify(observer2, times(1)).onNext(1);
+        inOrder2.verify(observer2, times(1)).onNext(2);
+        inOrder2.verify(observer2, times(1)).onNext(3);
+        inOrder2.verify(observer2, times(1)).onCompleted();
+        verify(observer2, never()).onError(any(Throwable.class));
+        inOrder2.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void observeSameOnMultipleSchedulers() {
+        TestScheduler scheduler1 = new TestScheduler();
+        TestScheduler scheduler2 = new TestScheduler();
+
+        Observable o = Observable.from(1, 2, 3);
+        Observable o1 = o.lift(new OperatorObserveOnBounded(scheduler1, 1));
+        Observable o2 = o.lift(new OperatorObserveOnBounded(scheduler2, 1));
+
+        @SuppressWarnings("unchecked")
+        Observer observer1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
+        Observer observer2 = mock(Observer.class);
+
+        InOrder inOrder1 = inOrder(observer1);
+        InOrder inOrder2 = inOrder(observer2);
+
+        o1.subscribe(observer1);
+        o2.subscribe(observer2);
+
+        scheduler1.advanceTimeBy(1, TimeUnit.SECONDS);
+        scheduler2.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        inOrder1.verify(observer1, times(1)).onNext(1);
+        inOrder1.verify(observer1, times(1)).onNext(2);
+        inOrder1.verify(observer1, times(1)).onNext(3);
+        inOrder1.verify(observer1, times(1)).onCompleted();
+        verify(observer1, never()).onError(any(Throwable.class));
+        inOrder1.verifyNoMoreInteractions();
+
+        inOrder2.verify(observer2, times(1)).onNext(1);
+        inOrder2.verify(observer2, times(1)).onNext(2);
+        inOrder2.verify(observer2, times(1)).onNext(3);
+        inOrder2.verify(observer2, times(1)).onCompleted();
+        verify(observer2, never()).onError(any(Throwable.class));
+        inOrder2.verifyNoMoreInteractions();
+    }
+
+    /**
+     * Confirm that running on a NewThreadScheduler uses the same thread for the entire stream
+     */
+    @Test
+    public void testObserveOnWithNewThreadScheduler() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 100000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                return t1 * _multiple;
+            }
+
+        }).lift(new OperatorObserveOnBounded(Schedulers.newThread(), 1))
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxNewThreadScheduler"));
+                    }
+
+                });
+    }
+
+    /**
+     * Confirm that running on a ThreadPoolScheduler allows multiple threads but is still ordered.
+     */
+    @Test
+    public void testObserveOnWithThreadPoolScheduler() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 100000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                return t1 * _multiple;
+            }
+
+        }).lift(new OperatorObserveOnBounded(Schedulers.computation(), 1))
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                    }
+
+                });
+    }
+
+    /**
+     * Attempts to confirm that when pauses exist between events, the ScheduledObserver
+     * does not lose or reorder any events since the scheduler will not block, but will
+     * be re-scheduled when it receives new events after each pause.
+     * 
+     * 
+     * This is non-deterministic in proving success, but if it ever fails (non-deterministically)
+     * it is a sign of potential issues as thread-races and scheduling should not affect output.
+     */
+    @Test
+    public void testObserveOnOrderingConcurrency() {
+        final AtomicInteger count = new AtomicInteger();
+        final int _multiple = 99;
+
+        Observable.range(1, 10000).map(new Func1() {
+
+            @Override
+            public Integer call(Integer t1) {
+                if (randomIntFrom0to100() > 98) {
+                    try {
+                        Thread.sleep(2);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+                return t1 * _multiple;
+            }
+
+        }).lift(new OperatorObserveOnBounded(Schedulers.computation(), 1))
+                .toBlockingObservable().forEach(new Action1() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                    }
+
+                });
+    }
+
+    @Test
+    public void testNonBlockingOuterWhileBlockingOnNext() throws InterruptedException {
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicLong completeTime = new AtomicLong();
+        // use subscribeOn to make async, observeOn to move
+        Observable.range(1, 1000).subscribeOn(Schedulers.newThread()).lift(new OperatorObserveOnBounded(Schedulers.newThread(), 1)).subscribe(new Observer() {
+
+            @Override
+            public void onCompleted() {
+                System.out.println("onCompleted");
+                completeTime.set(System.nanoTime());
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(Integer t) {
+
+            }
+
+        });
+
+        long afterSubscribeTime = System.nanoTime();
+        System.out.println("After subscribe: " + latch.getCount());
+        assertEquals(1, latch.getCount());
+        latch.await();
+        assertTrue(completeTime.get() > afterSubscribeTime);
+        System.out.println("onComplete nanos after subscribe: " + (completeTime.get() - afterSubscribeTime));
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThread() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 1);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThreadAndBuffer8() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 8);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeIO() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.io(), 1);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTrampoline() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.trampoline(), 1);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTestScheduler() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.test(), 1);
+    }
+
+    @Test
+    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeComputation() throws InterruptedException {
+        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.computation(), 1);
+    }
+
+    private final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Scheduler scheduler, int bufferSize) throws InterruptedException {
+        final AtomicInteger countEmitted = new AtomicInteger();
+        final AtomicInteger countTaken = new AtomicInteger();
+        int value = Observable.create(new OnSubscribeFunc() {
+
+            @Override
+            public Subscription onSubscribe(final Observer o) {
+                final BooleanSubscription s = BooleanSubscription.create();
+                Thread t = new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        int i = 1;
+                        while (!s.isUnsubscribed() && i <= 100) {
+                            //                            System.out.println("onNext from fast producer [" + Thread.currentThread() + "]: " + i);
+                            o.onNext(i++);
+                        }
+                        o.onCompleted();
+                    }
+                });
+                t.setDaemon(true);
+                t.start();
+                return s;
+            }
+        }).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                countEmitted.incrementAndGet();
+            }
+        }).doOnCompleted(new Action0() {
+
+            @Override
+            public void call() {
+                //                System.out.println("-------- Done Emitting from Source ---------");
+            }
+        }).lift(new OperatorObserveOnBounded(scheduler, bufferSize)).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer i) {
+                //                System.out.println(">> onNext to slowConsumer  [" + Thread.currentThread() + "] pre-take: " + i);
+                //force it to be slower than the producer
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                countTaken.incrementAndGet();
+            }
+        }).take(10).doOnNext(new Action1() {
+
+            @Override
+            public void call(Integer t) {
+                System.out.println("*********** value: " + t);
+            }
+
+        }).toBlockingObservable().last();
+
+        if (scheduler instanceof TrampolineScheduler || scheduler instanceof ImmediateScheduler || scheduler instanceof TestScheduler) {
+            // since there is no concurrency it will block and only emit as many as it can process
+            assertEquals(10, countEmitted.get());
+        } else {
+            // the others with concurrency should not emit all 100 ... but 10 + 2 in the pipeline
+            // NOTE: The +2 could change if the implementation of the queue logic changes. See Javadoc at top of class.
+            assertEquals(11, countEmitted.get(), bufferSize); // can be up to 11 + bufferSize
+        }
+        // number received after take (but take will filter any extra)
+        assertEquals(10, value);
+        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
+        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
+        // we expect only 10 to make it through the observeOn side
+        assertEquals(10, countTaken.get());
+    }
+
+    private static int randomIntFrom0to100() {
+        // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
+        long x = System.nanoTime();
+        x ^= (x << 21);
+        x ^= (x >>> 35);
+        x ^= (x << 4);
+        return Math.abs((int) x % 100);
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 7e522eccef..f02970118c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -346,109 +346,6 @@ public void onNext(Integer t) {
         System.out.println("onComplete nanos after subscribe: " + (completeTime.get() - afterSubscribeTime));
     }
 
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThread() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 1);
-    }
-
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeNewThreadAndBuffer8() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.newThread(), 8);
-    }
-
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeIO() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.io(), 1);
-    }
-
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTrampoline() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.trampoline(), 1);
-    }
-
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeTestScheduler() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.test(), 1);
-    }
-
-    @Test
-    public final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribeComputation() throws InterruptedException {
-        testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Schedulers.computation(), 1);
-    }
-
-    private final void testBackpressureOnFastProducerSlowConsumerWithUnsubscribe(Scheduler scheduler, int bufferSize) throws InterruptedException {
-        final AtomicInteger countEmitted = new AtomicInteger();
-        final AtomicInteger countTaken = new AtomicInteger();
-        int value = Observable.create(new OnSubscribeFunc() {
-
-            @Override
-            public Subscription onSubscribe(final Observer o) {
-                final BooleanSubscription s = BooleanSubscription.create();
-                Thread t = new Thread(new Runnable() {
-
-                    @Override
-                    public void run() {
-                        int i = 1;
-                        while (!s.isUnsubscribed() && i <= 100) {
-                            //                            System.out.println("onNext from fast producer [" + Thread.currentThread() + "]: " + i);
-                            o.onNext(i++);
-                        }
-                        o.onCompleted();
-                    }
-                });
-                t.setDaemon(true);
-                t.start();
-                return s;
-            }
-        }).doOnNext(new Action1() {
-
-            @Override
-            public void call(Integer i) {
-                countEmitted.incrementAndGet();
-            }
-        }).doOnCompleted(new Action0() {
-
-            @Override
-            public void call() {
-                //                System.out.println("-------- Done Emitting from Source ---------");
-            }
-        }).observeOn(scheduler, bufferSize).doOnNext(new Action1() {
-
-            @Override
-            public void call(Integer i) {
-                //                System.out.println(">> onNext to slowConsumer  [" + Thread.currentThread() + "] pre-take: " + i);
-                //force it to be slower than the producer
-                try {
-                    Thread.sleep(10);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                countTaken.incrementAndGet();
-            }
-        }).take(10).doOnNext(new Action1() {
-
-            @Override
-            public void call(Integer t) {
-                System.out.println("*********** value: " + t);
-            }
-
-        }).toBlockingObservable().last();
-
-        if (scheduler instanceof TrampolineScheduler || scheduler instanceof ImmediateScheduler || scheduler instanceof TestScheduler) {
-            // since there is no concurrency it will block and only emit as many as it can process
-            assertEquals(10, countEmitted.get());
-        } else {
-            // the others with concurrency should not emit all 100 ... but 10 + 2 in the pipeline
-            // NOTE: The +2 could change if the implementation of the queue logic changes. See Javadoc at top of class.
-            assertEquals(11, countEmitted.get(), bufferSize); // can be up to 11 + bufferSize
-        }
-        // number received after take (but take will filter any extra)
-        assertEquals(10, value);
-        // so we also want to check the doOnNext after observeOn to see if it got unsubscribed
-        Thread.sleep(200); // let time pass to see if the scheduler is still doing work
-        // we expect only 10 to make it through the observeOn side
-        assertEquals(10, countTaken.get());
-    }
 
     private static int randomIntFrom0to100() {
         // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml

From 873fa75bf80fb6dd05c53d791eac8441147c528b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:30:48 -0800
Subject: [PATCH 410/441] Split SubscribeOn into SubscribeOn/UnsubscribeOn

Working with @headinthebox based on discussions at https://github.com/Netflix/RxJava/pull/869 and https://github.com/Netflix/RxJava/pull/880#issuecomment-35163539 we determined that there are times when `unsubscribeOn` behavior is needed.

The `subscribeOn` operator can not mix `subscribe` and `unsubscribe` scheduling behavior without breaking the `lift`/`Subscriber` behavior that allows unsubscribing synchronous sources. The newly added `unsubscribeOn` operator will not work with synchronous unsubscribes, but it will work for the targeted use cases such as UI event handlers.
---
 rxjava-core/src/main/java/rx/Observable.java  |  18 +-
 .../rx/operators/OperatorSubscribeOn.java     |  64 +--
 .../operators/OperatorSubscribeOnBounded.java | 113 +++++
 .../rx/operators/OperatorUnsubscribeOn.java   |  79 ++++
 .../rx/operators/OperatorGroupByTest.java     |   4 +-
 .../OperatorSubscribeOnBoundedTest.java       | 403 ++++++++++++++++++
 .../rx/operators/OperatorSubscribeOnTest.java | 279 +-----------
 .../operators/OperatorUnsubscribeOnTest.java  | 190 +++++++++
 8 files changed, 814 insertions(+), 336 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 82e65c46f5..bb9953ca1e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -108,6 +108,7 @@
 import rx.operators.OperatorTimestamp;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
+import rx.operators.OperatorUnsubscribeOn;
 import rx.operators.OperatorZip;
 import rx.operators.OperatorZipIterable;
 import rx.plugins.RxJavaObservableExecutionHook;
@@ -7074,14 +7075,14 @@ public final Subscription subscribe(Subscriber observer, Scheduler sc
     }
 
     /**
-     * Asynchronously subscribes and unsubscribes Observers to this Observable on the specified
+     * Asynchronously subscribes Observers to this Observable 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
+     *            the {@link Scheduler} to perform subscription actions on
+     * @return the source Observable modified so that its subscriptions happen on the
      *         specified {@link Scheduler}
      * @see RxJava Wiki: subscribeOn()
      * @see #subscribeOn(rx.Scheduler, int) 
@@ -8204,6 +8205,17 @@ public final Observable> toSortedList(Func2(sortFunction));
     }
 
+    /**
+     * Asynchronously unsubscribes 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 unsubscriptions happen on the specified {@link Scheduler}
+     */
+    public final Observable unsubscribeOn(Scheduler scheduler) {
+        return lift(new OperatorUnsubscribeOn(scheduler));
+    }
+    
     /**
      * Returns an Observable that represents a filtered version of the source Observable.
      * 
    
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index b8e782ef37..0c49a38162 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -23,46 +23,16 @@
 import rx.util.functions.Action1;
 
 /**
- * Subscribes and unsubscribes Observers on the specified Scheduler.
+ * Subscribes Observers on the specified Scheduler.
  * 
    
- * Will occur asynchronously except when subscribing to `GroupedObservable`, `PublishSubject` and possibly other "hot" Observables
- * in which case it will subscribe synchronously and buffer/block onNext calls until the subscribe has occurred.
- * 
    
- * See https://github.com/Netflix/RxJava/issues/844 for more information on the "time gap" issue that the synchronous
- * subscribe is solving.
- * 
  * 
  */
 public class OperatorSubscribeOn implements Operator> {
 
     private final Scheduler scheduler;
-    /**
-     * Indicate that events fired between the original subscription time and
-     * the actual subscription time should not get lost.
-     */
-    private final boolean dontLoseEvents;
-    /** The buffer size to avoid flooding. Negative value indicates an unbounded buffer. */
-    private final int bufferSize;
 
     public OperatorSubscribeOn(Scheduler scheduler) {
         this.scheduler = scheduler;
-        this.dontLoseEvents = false;
-        this.bufferSize = -1;
-    }
-
-    /**
-     * Construct a SubscribeOn operator.
-     * 
-     * @param scheduler
-     *            the target scheduler
-     * @param bufferSize
-     *            if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
-     *            block the source. -1 indicates an unbounded buffer
-     */
-    public OperatorSubscribeOn(Scheduler scheduler, int bufferSize) {
-        this.scheduler = scheduler;
-        this.dontLoseEvents = true;
-        this.bufferSize = bufferSize;
     }
 
     @Override
@@ -71,7 +41,7 @@ public Subscriber> call(final Subscriber subscr
 
             @Override
             public void onCompleted() {
-                // ignore
+                // ignore because this is a nested Observable and we expect only 1 Observable emitted to onNext
             }
 
             @Override
@@ -79,33 +49,15 @@ public void onError(Throwable e) {
                 subscriber.onError(e);
             }
 
-            boolean checkNeedBuffer(Observable o) {
-                return dontLoseEvents;
-            }
-
             @Override
             public void onNext(final Observable o) {
-                if (checkNeedBuffer(o)) {
-                    // use buffering (possibly blocking) for a possibly synchronous subscribe
-                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(bufferSize, subscriber);
-                    o.subscribe(bus);
-                    subscriber.add(scheduler.schedule(new Action1() {
-                        @Override
-                        public void call(final Inner inner) {
-                            bus.enterPassthroughMode();
-                        }
-                    }));
-                    return;
-                } else {
-                    // no buffering (async subscribe)
-                    subscriber.add(scheduler.schedule(new Action1() {
+                subscriber.add(scheduler.schedule(new Action1() {
 
-                        @Override
-                        public void call(final Inner inner) {
-                            o.subscribe(subscriber);
-                        }
-                    }));
-                }
+                    @Override
+                    public void call(final Inner inner) {
+                        o.subscribe(subscriber);
+                    }
+                }));
             }
 
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
new file mode 100644
index 0000000000..284cfcc5bd
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
@@ -0,0 +1,113 @@
+/**
+ * Copyright 2014 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 rx.Observable;
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.util.functions.Action1;
+
+/**
+ * Subscribes and unsubscribes Observers on the specified Scheduler.
+ * 
    
+ * Will occur asynchronously except when subscribing to `GroupedObservable`, `PublishSubject` and possibly other "hot" Observables
+ * in which case it will subscribe synchronously and buffer/block onNext calls until the subscribe has occurred.
+ * 
    
+ * See https://github.com/Netflix/RxJava/issues/844 for more information on the "time gap" issue that the synchronous
+ * subscribe is solving.
+ * 
+ * 
+ */
+public class OperatorSubscribeOnBounded implements Operator> {
+
+    private final Scheduler scheduler;
+    /**
+     * Indicate that events fired between the original subscription time and
+     * the actual subscription time should not get lost.
+     */
+    private final boolean dontLoseEvents;
+    /** The buffer size to avoid flooding. Negative value indicates an unbounded buffer. */
+    private final int bufferSize;
+
+    public OperatorSubscribeOnBounded(Scheduler scheduler) {
+        this.scheduler = scheduler;
+        this.dontLoseEvents = false;
+        this.bufferSize = -1;
+    }
+
+    /**
+     * Construct a SubscribeOn operator.
+     * 
+     * @param scheduler
+     *            the target scheduler
+     * @param bufferSize
+     *            if dontLoseEvents == true, this indicates the buffer size. Filling the buffer will
+     *            block the source. -1 indicates an unbounded buffer
+     */
+    public OperatorSubscribeOnBounded(Scheduler scheduler, int bufferSize) {
+        this.scheduler = scheduler;
+        this.dontLoseEvents = true;
+        this.bufferSize = bufferSize;
+    }
+
+    @Override
+    public Subscriber> call(final Subscriber subscriber) {
+        return new Subscriber>(subscriber) {
+
+            @Override
+            public void onCompleted() {
+                // ignore
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            boolean checkNeedBuffer(Observable o) {
+                return dontLoseEvents;
+            }
+
+            @Override
+            public void onNext(final Observable o) {
+                if (checkNeedBuffer(o)) {
+                    // use buffering (possibly blocking) for a possibly synchronous subscribe
+                    final BufferUntilSubscriber bus = new BufferUntilSubscriber(bufferSize, subscriber);
+                    o.subscribe(bus);
+                    subscriber.add(scheduler.schedule(new Action1() {
+                        @Override
+                        public void call(final Inner inner) {
+                            bus.enterPassthroughMode();
+                        }
+                    }));
+                    return;
+                } else {
+                    // no buffering (async subscribe)
+                    subscriber.add(scheduler.schedule(new Action1() {
+
+                        @Override
+                        public void call(final Inner inner) {
+                            o.subscribe(subscriber);
+                        }
+                    }));
+                }
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
new file mode 100644
index 0000000000..0d734c5f73
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright 2014 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 rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+/**
+ * Unsubscribes on the specified Scheduler.
+ * 
    
+ */
+public class OperatorUnsubscribeOn implements Operator {
+
+    private final Scheduler scheduler;
+
+    public OperatorUnsubscribeOn(Scheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber call(final Subscriber subscriber) {
+        final CompositeSubscription parentSubscription = new CompositeSubscription();
+        subscriber.add(Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+                mas.set(scheduler.schedule(new Action1() {
+
+                    @Override
+                    public void call(final Inner inner) {
+                        parentSubscription.unsubscribe();
+                        mas.unsubscribe();
+                    }
+                }));
+            }
+
+        }));
+
+        return new Subscriber(parentSubscription) {
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                subscriber.onNext(t);
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 2f201dbb1b..7d4d98aace 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -700,7 +700,7 @@ public void call() {
 
                             });
                 } else {
-                    return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 1)).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+                    return group.nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread(), 1)).delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
 
                         @Override
                         public String call(Integer t1) {
@@ -826,7 +826,7 @@ public Integer call(Integer t) {
 
             @Override
             public Observable call(final GroupedObservable group) {
-                return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0)).map(new Func1() {
+                return group.nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread(), 0)).map(new Func1() {
 
                     @Override
                     public String call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
new file mode 100644
index 0000000000..cbd94e59d7
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
@@ -0,0 +1,403 @@
+/**
+ * Copyright 2014 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 static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observables.GroupedObservable;
+import rx.observers.TestObserver;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+import rx.subscriptions.Subscriptions;
+import rx.util.Timestamped;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public class OperatorSubscribeOnBoundedTest {
+
+    private static class ThreadSubscription implements Subscription {
+        private volatile Thread thread;
+
+        private final CountDownLatch latch = new CountDownLatch(1);
+
+        private final Subscription s = Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                thread = Thread.currentThread();
+                latch.countDown();
+            }
+
+        });
+
+        @Override
+        public void unsubscribe() {
+            s.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return s.isUnsubscribed();
+        }
+
+        public Thread getThread() throws InterruptedException {
+            latch.await();
+            return thread;
+        }
+    }
+
+    @Test
+    public void testSubscribeOnAndVerifySubscribeAndUnsubscribeThreads()
+            throws InterruptedException {
+        final ThreadSubscription subscription = new ThreadSubscription();
+        final AtomicReference subscribeThread = new AtomicReference();
+        Observable w = Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber t1) {
+                subscribeThread.set(Thread.currentThread());
+                t1.add(subscription);
+                t1.onNext(1);
+                t1.onNext(2);
+                t1.onCompleted();
+            }
+        });
+
+        TestObserver observer = new TestObserver();
+        w.nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread())).subscribe(observer);
+
+        Thread unsubscribeThread = subscription.getThread();
+
+        assertNotNull(unsubscribeThread);
+        assertNotSame(Thread.currentThread(), unsubscribeThread);
+
+        assertNotNull(subscribeThread.get());
+        assertNotSame(Thread.currentThread(), subscribeThread.get());
+        // True for Schedulers.newThread()
+        assertTrue(unsubscribeThread == subscribeThread.get());
+
+        observer.assertReceivedOnNext(Arrays.asList(1, 2));
+        observer.assertTerminalEvent();
+    }
+
+    @Test(timeout = 2000)
+    public void testIssue813() throws InterruptedException {
+        // https://github.com/Netflix/RxJava/issues/813
+        final CountDownLatch scheduled = new CountDownLatch(1);
+        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch doneLatch = new CountDownLatch(1);
+
+        TestObserver observer = new TestObserver();
+        final ThreadSubscription s = new ThreadSubscription();
+
+        final Subscription subscription = Observable
+                .create(new Observable.OnSubscribe() {
+                    @Override
+                    public void call(
+                            final Subscriber subscriber) {
+                        subscriber.add(s);
+                        scheduled.countDown();
+                        try {
+                            latch.await();
+
+                            // this should not run because the await above will be interrupted by the unsubscribe
+                            subscriber.onCompleted();
+                        } catch (InterruptedException e) {
+                            System.out.println("Interrupted because it is unsubscribed");
+                            Thread.currentThread().interrupt();
+                        } catch (Throwable e) {
+                            subscriber.onError(e);
+                        } finally {
+                            doneLatch.countDown();
+                        }
+                    }
+                }).nest().lift(new OperatorSubscribeOnBounded(Schedulers.computation())).subscribe(observer);
+
+        // wait for scheduling
+        scheduled.await();
+        // trigger unsubscribe
+        subscription.unsubscribe();
+        // As unsubscribe is called in other thread, we need to wait for it.
+        s.getThread();
+        latch.countDown();
+        doneLatch.await();
+        assertEquals(0, observer.getOnErrorEvents().size());
+        // 0 because the unsubscribe interrupts and prevents onCompleted from being executed
+        assertEquals(0, observer.getOnCompletedEvents().size());
+    }
+
+    public static class SlowScheduler extends Scheduler {
+        final Scheduler actual;
+        final long delay;
+        final TimeUnit unit;
+
+        public SlowScheduler() {
+            this(Schedulers.computation(), 2, TimeUnit.SECONDS);
+        }
+
+        public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
+            this.actual = actual;
+            this.delay = delay;
+            this.unit = unit;
+        }
+
+        @Override
+        public Subscription schedule(final Action1 action) {
+            return actual.schedule(action, delay, unit);
+        }
+
+        @Override
+        public Subscription schedule(final Action1 action, final long delayTime, final TimeUnit delayUnit) {
+            TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit;
+            long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit);
+            return actual.schedule(action, t, common);
+        }
+    }
+
+    @Test
+    public void testSubscribeOnPublishSubjectWithSlowScheduler() {
+        PublishSubject ps = PublishSubject.create();
+        TestSubscriber ts = new TestSubscriber();
+        ps.nest().lift(new OperatorSubscribeOnBounded(new SlowScheduler(), 0)).subscribe(ts);
+        ps.onNext(1);
+        ps.onNext(2);
+        ps.onCompleted();
+
+        ts.awaitTerminalEvent();
+        ts.assertReceivedOnNext(Arrays.asList(1, 2));
+    }
+
+    @Test
+    public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                return group.nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread(), 0)).map(new Func1() {
+
+                    @Override
+                    public String call(Integer t1) {
+                        System.out.println("Received: " + t1 + " on group : " + group.getKey());
+                        return "first groups: " + t1;
+                    }
+
+                });
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(4, results.size());
+    }
+
+    @Test
+    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
+        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
+        final ArrayList results = new ArrayList();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                sub.onNext(1);
+                sub.onNext(2);
+                sub.onNext(1);
+                sub.onNext(2);
+                try {
+                    first.await();
+                } catch (InterruptedException e) {
+                    sub.onError(e);
+                    return;
+                }
+                sub.onNext(3);
+                sub.onNext(3);
+                sub.onCompleted();
+            }
+
+        }).groupBy(new Func1() {
+
+            @Override
+            public Integer call(Integer t) {
+                return t;
+            }
+
+        }).flatMap(new Func1, Observable>() {
+
+            @Override
+            public Observable call(final GroupedObservable group) {
+                if (group.getKey() < 3) {
+                    return group.map(new Func1() {
+
+                        @Override
+                        public String call(Integer t1) {
+                            return "first groups: " + t1;
+                        }
+
+                    })
+                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
+                            .take(2).doOnCompleted(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    first.countDown();
+                                }
+
+                            });
+                } else {
+                    return group.nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread(), 0))
+                            .delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
+
+                                @Override
+                                public String call(Integer t1) {
+                                    return "last group: " + t1;
+                                }
+
+                            });
+                }
+            }
+
+        }).toBlockingObservable().forEach(new Action1() {
+
+            @Override
+            public void call(String s) {
+                results.add(s);
+            }
+
+        });
+
+        System.out.println("Results: " + results);
+        assertEquals(6, results.size());
+    }
+
+    void testBoundedBufferingWithSize(int size) throws Exception {
+        Observable timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS);
+
+        final List deltas = Collections.synchronizedList(new ArrayList());
+
+        Subscription s = timer.timestamp().nest().lift(new OperatorSubscribeOnBounded>(
+                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size)).map(new Func1, Long>() {
+            @Override
+            public Long call(Timestamped t1) {
+                long v = System.currentTimeMillis() - t1.getTimestampMillis();
+                return v;
+            }
+        }).doOnNext(new Action1() {
+            @Override
+            public void call(Long t1) {
+                deltas.add(t1);
+            }
+        }).subscribe();
+
+        Thread.sleep(2050);
+
+        s.unsubscribe();
+
+        if (deltas.size() < size + 1) {
+            fail("To few items in deltas: " + deltas);
+        }
+        for (int i = 0; i < size + 1; i++) {
+            if (deltas.get(i) < 500) {
+                fail(i + "th item arrived too early: " + deltas);
+            }
+        }
+        for (int i = size + 1; i < deltas.size(); i++) {
+            if (deltas.get(i) >= 500) {
+                fail(i + "th item arrived too late: " + deltas);
+            }
+        }
+    }
+
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfZero() throws Exception {
+        testBoundedBufferingWithSize(0);
+    }
+
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfOne() throws Exception {
+        testBoundedBufferingWithSize(1);
+    }
+
+    @Test(timeout = 5000)
+    public void testBoundedBufferingOfTwo() throws Exception {
+        testBoundedBufferingWithSize(2);
+    }
+
+    @Test(timeout = 5000)
+    public void testUnsubscribeInfiniteStream() throws InterruptedException {
+        TestSubscriber ts = new TestSubscriber();
+        final AtomicInteger count = new AtomicInteger();
+        Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber sub) {
+                for (int i = 1; !sub.isUnsubscribed(); i++) {
+                    count.incrementAndGet();
+                    sub.onNext(i);
+                }
+            }
+
+        }).nest().lift(new OperatorSubscribeOnBounded(Schedulers.newThread())).take(10).subscribe(ts);
+
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(1000, TimeUnit.MILLISECONDS);
+        Thread.sleep(200); // give time for the loop to continue
+        ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+        assertEquals(10, count.get());
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 54d348dc3c..8e2e75b66b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -17,14 +17,10 @@
 
 import static org.junit.Assert.*;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
 
@@ -33,84 +29,13 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.observables.GroupedObservable;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
-import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
-import rx.util.Timestamped;
-import rx.util.functions.Action0;
 import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorSubscribeOnTest {
 
-    private static class ThreadSubscription implements Subscription {
-        private volatile Thread thread;
-
-        private final CountDownLatch latch = new CountDownLatch(1);
-
-        private final Subscription s = Subscriptions.create(new Action0() {
-
-            @Override
-            public void call() {
-                thread = Thread.currentThread();
-                latch.countDown();
-            }
-
-        });
-
-        @Override
-        public void unsubscribe() {
-            s.unsubscribe();
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return s.isUnsubscribed();
-        }
-
-        public Thread getThread() throws InterruptedException {
-            latch.await();
-            return thread;
-        }
-    }
-
-    @Test
-    public void testSubscribeOnAndVerifySubscribeAndUnsubscribeThreads()
-            throws InterruptedException {
-        final ThreadSubscription subscription = new ThreadSubscription();
-        final AtomicReference subscribeThread = new AtomicReference();
-        Observable w = Observable.create(new OnSubscribe() {
-
-            @Override
-            public void call(Subscriber t1) {
-                subscribeThread.set(Thread.currentThread());
-                t1.add(subscription);
-                t1.onNext(1);
-                t1.onNext(2);
-                t1.onCompleted();
-            }
-        });
-
-        TestObserver observer = new TestObserver();
-        w.subscribeOn(Schedulers.newThread()).subscribe(observer);
-
-        Thread unsubscribeThread = subscription.getThread();
-
-        assertNotNull(unsubscribeThread);
-        assertNotSame(Thread.currentThread(), unsubscribeThread);
-
-        assertNotNull(subscribeThread.get());
-        assertNotSame(Thread.currentThread(), subscribeThread.get());
-        // True for Schedulers.newThread()
-        assertTrue(unsubscribeThread == subscribeThread.get());
-
-        observer.assertReceivedOnNext(Arrays.asList(1, 2));
-        observer.assertTerminalEvent();
-    }
-
     @Test(timeout = 2000)
     public void testIssue813() throws InterruptedException {
         // https://github.com/Netflix/RxJava/issues/813
@@ -119,23 +44,22 @@ public void testIssue813() throws InterruptedException {
         final CountDownLatch doneLatch = new CountDownLatch(1);
 
         TestObserver observer = new TestObserver();
-        final ThreadSubscription s = new ThreadSubscription();
 
         final Subscription subscription = Observable
                 .create(new Observable.OnSubscribe() {
                     @Override
                     public void call(
                             final Subscriber subscriber) {
-                        subscriber.add(s);
                         scheduled.countDown();
                         try {
                             latch.await();
 
+                            System.out.println("emit onCompleted");
                             // this should not run because the await above will be interrupted by the unsubscribe
                             subscriber.onCompleted();
                         } catch (InterruptedException e) {
-                            System.out.println("Interrupted because it is unsubscribed");
-                            Thread.currentThread().interrupt();
+                            e.printStackTrace();
+                            throw new RuntimeException("should not occur since we are not interuppting");
                         } catch (Throwable e) {
                             subscriber.onError(e);
                         } finally {
@@ -148,12 +72,10 @@ public void call(
         scheduled.await();
         // trigger unsubscribe
         subscription.unsubscribe();
-        // As unsubscribe is called in other thread, we need to wait for it.
-        s.getThread();
         latch.countDown();
         doneLatch.await();
         assertEquals(0, observer.getOnErrorEvents().size());
-        // 0 because the unsubscribe interrupts and prevents onCompleted from being executed
+        // the unsubscribe shuts down the scheduler which causes the latch to be interrupted
         assertEquals(0, observer.getOnCompletedEvents().size());
     }
 
@@ -185,199 +107,6 @@ public Subscription schedule(final Action1 action, final long d
         }
     }
 
-    @Test
-    public void testSubscribeOnPublishSubjectWithSlowScheduler() {
-        PublishSubject ps = PublishSubject.create();
-        TestSubscriber ts = new TestSubscriber();
-        ps.nest().lift(new OperatorSubscribeOn(new SlowScheduler(), 0)).subscribe(ts);
-        ps.onNext(1);
-        ps.onNext(2);
-        ps.onCompleted();
-
-        ts.awaitTerminalEvent();
-        ts.assertReceivedOnNext(Arrays.asList(1, 2));
-    }
-
-    @Test
-    public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
-        final ArrayList results = new ArrayList();
-        Observable.create(new OnSubscribe() {
-
-            @Override
-            public void call(Subscriber sub) {
-                sub.onNext(1);
-                sub.onNext(2);
-                sub.onNext(1);
-                sub.onNext(2);
-                sub.onCompleted();
-            }
-
-        }).groupBy(new Func1() {
-
-            @Override
-            public Integer call(Integer t) {
-                return t;
-            }
-
-        }).flatMap(new Func1, Observable>() {
-
-            @Override
-            public Observable call(final GroupedObservable group) {
-                return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0)).map(new Func1() {
-
-                    @Override
-                    public String call(Integer t1) {
-                        System.out.println("Received: " + t1 + " on group : " + group.getKey());
-                        return "first groups: " + t1;
-                    }
-
-                });
-            }
-
-        }).toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String s) {
-                results.add(s);
-            }
-
-        });
-
-        System.out.println("Results: " + results);
-        assertEquals(4, results.size());
-    }
-
-    @Test
-    public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
-        final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
-        final ArrayList results = new ArrayList();
-        Observable.create(new OnSubscribe() {
-
-            @Override
-            public void call(Subscriber sub) {
-                sub.onNext(1);
-                sub.onNext(2);
-                sub.onNext(1);
-                sub.onNext(2);
-                try {
-                    first.await();
-                } catch (InterruptedException e) {
-                    sub.onError(e);
-                    return;
-                }
-                sub.onNext(3);
-                sub.onNext(3);
-                sub.onCompleted();
-            }
-
-        }).groupBy(new Func1() {
-
-            @Override
-            public Integer call(Integer t) {
-                return t;
-            }
-
-        }).flatMap(new Func1, Observable>() {
-
-            @Override
-            public Observable call(final GroupedObservable group) {
-                if (group.getKey() < 3) {
-                    return group.map(new Func1() {
-
-                        @Override
-                        public String call(Integer t1) {
-                            return "first groups: " + t1;
-                        }
-
-                    })
-                            // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups
-                            .take(2).doOnCompleted(new Action0() {
-
-                                @Override
-                                public void call() {
-                                    first.countDown();
-                                }
-
-                            });
-                } else {
-                    return group.nest().lift(new OperatorSubscribeOn(Schedulers.newThread(), 0))
-                            .delay(400, TimeUnit.MILLISECONDS).map(new Func1() {
-
-                                @Override
-                                public String call(Integer t1) {
-                                    return "last group: " + t1;
-                                }
-
-                            });
-                }
-            }
-
-        }).toBlockingObservable().forEach(new Action1() {
-
-            @Override
-            public void call(String s) {
-                results.add(s);
-            }
-
-        });
-
-        System.out.println("Results: " + results);
-        assertEquals(6, results.size());
-    }
-
-    void testBoundedBufferingWithSize(int size) throws Exception {
-        Observable timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS);
-
-        final List deltas = Collections.synchronizedList(new ArrayList());
-
-        Subscription s = timer.timestamp().nest().lift(new OperatorSubscribeOn>(
-                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size)).map(new Func1, Long>() {
-            @Override
-            public Long call(Timestamped t1) {
-                long v = System.currentTimeMillis() - t1.getTimestampMillis();
-                return v;
-            }
-        }).doOnNext(new Action1() {
-            @Override
-            public void call(Long t1) {
-                deltas.add(t1);
-            }
-        }).subscribe();
-
-        Thread.sleep(2050);
-
-        s.unsubscribe();
-
-        if (deltas.size() < size + 1) {
-            fail("To few items in deltas: " + deltas);
-        }
-        for (int i = 0; i < size + 1; i++) {
-            if (deltas.get(i) < 500) {
-                fail(i + "th item arrived too early: " + deltas);
-            }
-        }
-        for (int i = size + 1; i < deltas.size(); i++) {
-            if (deltas.get(i) >= 500) {
-                fail(i + "th item arrived too late: " + deltas);
-            }
-        }
-    }
-
-    @Test(timeout = 5000)
-    public void testBoundedBufferingOfZero() throws Exception {
-        testBoundedBufferingWithSize(0);
-    }
-
-    @Test(timeout = 5000)
-    public void testBoundedBufferingOfOne() throws Exception {
-        testBoundedBufferingWithSize(1);
-    }
-
-    @Test(timeout = 5000)
-    public void testBoundedBufferingOfTwo() throws Exception {
-        testBoundedBufferingWithSize(2);
-    }
-
     @Test(timeout = 5000)
     public void testUnsubscribeInfiniteStream() throws InterruptedException {
         TestSubscriber ts = new TestSubscriber();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
new file mode 100644
index 0000000000..9aa75c39c0
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -0,0 +1,190 @@
+package rx.operators;
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observers.TestObserver;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+
+public class OperatorUnsubscribeOnTest {
+
+    @Test
+    public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnSameThread() throws InterruptedException {
+        UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler();
+        try {
+            final ThreadSubscription subscription = new ThreadSubscription();
+            final AtomicReference subscribeThread = new AtomicReference();
+            Observable w = Observable.create(new OnSubscribe() {
+
+                @Override
+                public void call(Subscriber t1) {
+                    subscribeThread.set(Thread.currentThread());
+                    t1.add(subscription);
+                    t1.onNext(1);
+                    t1.onNext(2);
+                    t1.onCompleted();
+                }
+            });
+
+            TestObserver observer = new TestObserver();
+            w.subscribeOn(UI_EVENT_LOOP).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(observer);
+
+            Thread unsubscribeThread = subscription.getThread();
+
+            assertNotNull(unsubscribeThread);
+            assertNotSame(Thread.currentThread(), unsubscribeThread);
+
+            assertNotNull(subscribeThread.get());
+            assertNotSame(Thread.currentThread(), subscribeThread.get());
+            // True for Schedulers.newThread()
+
+            System.out.println("unsubscribeThread: " + unsubscribeThread);
+            System.out.println("subscribeThread.get(): " + subscribeThread.get());
+            assertTrue(unsubscribeThread == UI_EVENT_LOOP.getThread());
+
+            observer.assertReceivedOnNext(Arrays.asList(1, 2));
+            observer.assertTerminalEvent();
+        } finally {
+            UI_EVENT_LOOP.shutdown();
+        }
+    }
+
+    @Test
+    public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnDifferentThreads() throws InterruptedException {
+        UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler();
+        try {
+            final ThreadSubscription subscription = new ThreadSubscription();
+            final AtomicReference subscribeThread = new AtomicReference();
+            Observable w = Observable.create(new OnSubscribe() {
+
+                @Override
+                public void call(Subscriber t1) {
+                    subscribeThread.set(Thread.currentThread());
+                    t1.add(subscription);
+                    t1.onNext(1);
+                    t1.onNext(2);
+                    t1.onCompleted();
+                }
+            });
+
+            TestObserver observer = new TestObserver();
+            w.subscribeOn(Schedulers.newThread()).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(observer);
+
+            Thread unsubscribeThread = subscription.getThread();
+
+            assertNotNull(unsubscribeThread);
+            assertNotSame(Thread.currentThread(), unsubscribeThread);
+
+            assertNotNull(subscribeThread.get());
+            assertNotSame(Thread.currentThread(), subscribeThread.get());
+            // True for Schedulers.newThread()
+
+            System.out.println("unsubscribeThread: " + unsubscribeThread);
+            System.out.println("subscribeThread.get(): " + subscribeThread.get());
+            assertTrue(unsubscribeThread == UI_EVENT_LOOP.getThread());
+
+            observer.assertReceivedOnNext(Arrays.asList(1, 2));
+            observer.assertTerminalEvent();
+        } finally {
+            UI_EVENT_LOOP.shutdown();
+        }
+    }
+
+    private static class ThreadSubscription implements Subscription {
+        private volatile Thread thread;
+
+        private final CountDownLatch latch = new CountDownLatch(1);
+
+        private final Subscription s = Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                System.out.println("unsubscribe invoked: " + Thread.currentThread());
+                thread = Thread.currentThread();
+                latch.countDown();
+            }
+
+        });
+
+        @Override
+        public void unsubscribe() {
+            s.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return s.isUnsubscribed();
+        }
+
+        public Thread getThread() throws InterruptedException {
+            latch.await();
+            return thread;
+        }
+    }
+
+    public static class UIEventLoopScheduler extends Scheduler {
+
+        private final Scheduler.Inner eventLoop;
+        private final Subscription s;
+        private volatile Thread t;
+
+        public UIEventLoopScheduler() {
+            /*
+             * DON'T DO THIS IN PRODUCTION CODE
+             */
+            final AtomicReference innerScheduler = new AtomicReference();
+            final CountDownLatch latch = new CountDownLatch(1);
+            s = Schedulers.newThread().schedule(new Action1() {
+
+                @Override
+                public void call(Inner inner) {
+                    t = Thread.currentThread();
+                    innerScheduler.set(inner);
+                    latch.countDown();
+                }
+
+            });
+            try {
+                latch.await();
+            } catch (InterruptedException e) {
+                throw new RuntimeException("failed to initialize and get inner scheduler");
+            }
+            eventLoop = innerScheduler.get();
+        }
+
+        @Override
+        public Subscription schedule(Action1 action) {
+            eventLoop.schedule(action);
+            return Subscriptions.empty();
+        }
+
+        @Override
+        public Subscription schedule(Action1 action, long delayTime, TimeUnit unit) {
+            eventLoop.schedule(action);
+            return Subscriptions.empty();
+        }
+
+        public void shutdown() {
+            s.unsubscribe();
+        }
+
+        public Thread getThread() {
+            return t;
+        }
+
+    }
+}

From 9b61c134e929dbd5b17216a58453bc8baea9a666 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:52:24 -0800
Subject: [PATCH 411/441] Move Exception Classes to rx.exceptions

Eliminate dumping ground of rx.util
---
 rxjava-core/src/main/java/rx/Observable.java                | 4 ++--
 .../java/rx/{util => exceptions}/CompositeException.java    | 2 +-
 .../src/main/java/rx/{util => exceptions}/Exceptions.java   | 2 +-
 .../OnErrorNotImplementedException.java                     | 2 +-
 rxjava-core/src/main/java/rx/observers/Observers.java       | 2 +-
 rxjava-core/src/main/java/rx/observers/SafeSubscriber.java  | 6 +++---
 rxjava-core/src/main/java/rx/observers/Subscribers.java     | 2 +-
 rxjava-core/src/main/java/rx/operators/OperationLatest.java | 2 +-
 .../main/java/rx/operators/OperationMergeDelayError.java    | 2 +-
 .../src/main/java/rx/operators/OperationMostRecent.java     | 2 +-
 rxjava-core/src/main/java/rx/operators/OperationNext.java   | 2 +-
 .../rx/operators/OperationOnErrorResumeNextViaFunction.java | 2 +-
 .../src/main/java/rx/operators/OperationOnErrorReturn.java  | 2 +-
 .../src/main/java/rx/operators/OperationToIterator.java     | 2 +-
 .../main/java/rx/operators/OperatorTimeoutWithSelector.java | 2 +-
 rxjava-core/src/main/java/rx/operators/SafeObserver.java    | 4 ++--
 .../main/java/rx/subscriptions/CompositeSubscription.java   | 2 +-
 .../rx/{util => exceptions}/CompositeExceptionTest.java     | 6 +++++-
 .../test/java/rx/{util => exceptions}/ExceptionsTest.java   | 4 +++-
 .../src/test/java/rx/observers/SafeObserverTest.java        | 4 ++--
 .../java/rx/operators/OperationMergeDelayErrorTest.java     | 2 +-
 .../java/rx/subscriptions/CompositeSubscriptionTest.java    | 2 +-
 22 files changed, 33 insertions(+), 27 deletions(-)
 rename rxjava-core/src/main/java/rx/{util => exceptions}/CompositeException.java (99%)
 rename rxjava-core/src/main/java/rx/{util => exceptions}/Exceptions.java (98%)
 rename rxjava-core/src/main/java/rx/{util => exceptions}/OnErrorNotImplementedException.java (98%)
 rename rxjava-core/src/test/java/rx/{util => exceptions}/CompositeExceptionTest.java (96%)
 rename rxjava-core/src/test/java/rx/{util => exceptions}/ExceptionsTest.java (96%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index bb9953ca1e..16b36eaab3 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -24,6 +24,8 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
+import rx.exceptions.Exceptions;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
 import rx.observables.BlockingObservable;
@@ -120,8 +122,6 @@
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.Exceptions;
-import rx.util.OnErrorNotImplementedException;
 import rx.util.TimeInterval;
 import rx.util.Timestamped;
 import rx.util.functions.Action0;
diff --git a/rxjava-core/src/main/java/rx/util/CompositeException.java b/rxjava-core/src/main/java/rx/exceptions/CompositeException.java
similarity index 99%
rename from rxjava-core/src/main/java/rx/util/CompositeException.java
rename to rxjava-core/src/main/java/rx/exceptions/CompositeException.java
index 439b9400b2..af2dfa1948 100644
--- a/rxjava-core/src/main/java/rx/util/CompositeException.java
+++ b/rxjava-core/src/main/java/rx/exceptions/CompositeException.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.exceptions;
 
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/rxjava-core/src/main/java/rx/util/Exceptions.java b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/util/Exceptions.java
rename to rxjava-core/src/main/java/rx/exceptions/Exceptions.java
index c59f36129b..34f45e52ff 100644
--- a/rxjava-core/src/main/java/rx/util/Exceptions.java
+++ b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.exceptions;
 
 public class Exceptions {
     private Exceptions() {
diff --git a/rxjava-core/src/main/java/rx/util/OnErrorNotImplementedException.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/util/OnErrorNotImplementedException.java
rename to rxjava-core/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
index b50ea97419..15ca62a036 100644
--- a/rxjava-core/src/main/java/rx/util/OnErrorNotImplementedException.java
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.exceptions;
 
 import rx.Subscriber;
 
diff --git a/rxjava-core/src/main/java/rx/observers/Observers.java b/rxjava-core/src/main/java/rx/observers/Observers.java
index 5ca66aa54b..d8e5b41f73 100644
--- a/rxjava-core/src/main/java/rx/observers/Observers.java
+++ b/rxjava-core/src/main/java/rx/observers/Observers.java
@@ -1,7 +1,7 @@
 package rx.observers;
 
 import rx.Observer;
-import rx.util.OnErrorNotImplementedException;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index 0ff56ac759..1158d67b0b 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -19,10 +19,10 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Subscriber;
+import rx.exceptions.CompositeException;
+import rx.exceptions.Exceptions;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.plugins.RxJavaPlugins;
-import rx.util.CompositeException;
-import rx.util.Exceptions;
-import rx.util.OnErrorNotImplementedException;
 
 /**
  * Wrapper around Observer to ensure compliance with Rx contract.
diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
index 156656851f..07d209e36c 100644
--- a/rxjava-core/src/main/java/rx/observers/Subscribers.java
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.java
@@ -2,7 +2,7 @@
 
 import rx.Observer;
 import rx.Subscriber;
-import rx.util.OnErrorNotImplementedException;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
index 6cc213c37d..4fda664f93 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
@@ -23,7 +23,7 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
-import rx.util.Exceptions;
+import rx.exceptions.Exceptions;
 
 /**
  * Wait for and iterate over the latest values of the source observable.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index 2f13510da1..b2498df6c2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -24,10 +24,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.CompositeException;
 import rx.observers.SynchronizedObserver;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.CompositeException;
 
 /**
  * This behaves like {@link OperatorMerge} except that if any of the merged Observables notify of
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
index 7af2f3fb1a..4ae9ae5971 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
@@ -21,7 +21,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.Exceptions;
+import rx.exceptions.Exceptions;
 
 /**
  * Returns an Iterable that always returns the item most recently emitted by an Observable, or a
diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java
index d4d62b65b5..a37fba3cd1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java
@@ -24,7 +24,7 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
-import rx.util.Exceptions;
+import rx.exceptions.Exceptions;
 
 /**
  * Returns an Iterable that blocks until the Observable emits another item, then returns that item.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
index f4de4348cc..3aea40f6f0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
@@ -22,8 +22,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.CompositeException;
 import rx.subscriptions.Subscriptions;
-import rx.util.CompositeException;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
index 35b4f2afc7..84df5272a6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
@@ -22,8 +22,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.CompositeException;
 import rx.subscriptions.Subscriptions;
-import rx.util.CompositeException;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
index 318728c438..399083582d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
@@ -23,7 +23,7 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
-import rx.util.Exceptions;
+import rx.exceptions.Exceptions;
 
 /**
  * Returns an Iterator that iterates over all items emitted by a specified Observable.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index 82727dbb01..3932bd94f5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -18,8 +18,8 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.exceptions.Exceptions;
 import rx.subscriptions.Subscriptions;
-import rx.util.Exceptions;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 097fb84cea..f776619905 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -20,11 +20,11 @@
 
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.CompositeException;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.observers.SynchronizedObserver;
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.Subscriptions;
-import rx.util.CompositeException;
-import rx.util.OnErrorNotImplementedException;
 
 /**
  * Wrapper around Observer to ensure compliance with Rx contract.
diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 2b1b37e581..5aef85181d 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -20,7 +20,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Subscription;
-import rx.util.CompositeException;
+import rx.exceptions.CompositeException;
 
 /**
  * Subscription that represents a group of Subscriptions that are unsubscribed
diff --git a/rxjava-core/src/test/java/rx/util/CompositeExceptionTest.java b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
similarity index 96%
rename from rxjava-core/src/test/java/rx/util/CompositeExceptionTest.java
rename to rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
index 01cbeeb06b..14c4ad38f3 100644
--- a/rxjava-core/src/test/java/rx/util/CompositeExceptionTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.exceptions;
 
 import static org.junit.Assert.*;
 
@@ -23,6 +23,10 @@
 
 import org.junit.Test;
 
+import rx.util.CompositeException.CompositeExceptionCausalChain;
+
+import rx.exceptions.CompositeException;
+
 public class CompositeExceptionTest {
 
     private final Throwable ex1 = new Throwable("Ex1");
diff --git a/rxjava-core/src/test/java/rx/util/ExceptionsTest.java b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
similarity index 96%
rename from rxjava-core/src/test/java/rx/util/ExceptionsTest.java
rename to rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
index 8029038e0a..7a7c85d463 100644
--- a/rxjava-core/src/test/java/rx/util/ExceptionsTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -13,12 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.exceptions;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.OnErrorNotImplimport rx.util.OnErrorNotImplementedException;
+ementedException;
 import rx.subjects.PublishSubject;
 import rx.util.functions.Action1;
 
diff --git a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
index 4b8d2e42a5..d86f48a013 100644
--- a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
@@ -22,9 +22,9 @@
 import org.junit.Test;
 
 import rx.Subscriber;
+import rx.exceptions.CompositeException;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.subscriptions.Subscriptions;
-import rx.util.CompositeException;
-import rx.util.OnErrorNotImplementedException;
 import rx.util.functions.Action0;
 
 public class SafeObserverTest {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
index 60a05fd935..30ce59117a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
@@ -31,8 +31,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.CompositeException;
 import rx.subscriptions.Subscriptions;
-import rx.util.CompositeException;
 
 public class OperationMergeDelayErrorTest {
 
diff --git a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index ee2df6485b..d61929096c 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -25,7 +25,7 @@
 import org.junit.Test;
 
 import rx.Subscription;
-import rx.util.CompositeException;
+import rx.exceptions.CompositeException;
 
 public class CompositeSubscriptionTest {
 

From d960dca137dee5aa223126343c7cd670389b160f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:53:31 -0800
Subject: [PATCH 412/441] Move time based util classes to rx.schedulers

Eliminate dumping ground of rx.util
---
 rxjava-core/src/main/java/rx/Observable.java                  | 4 ++--
 rxjava-core/src/main/java/rx/operators/OperationReplay.java   | 2 +-
 rxjava-core/src/main/java/rx/operators/OperationSkipLast.java | 2 +-
 rxjava-core/src/main/java/rx/operators/OperationTakeLast.java | 2 +-
 .../src/main/java/rx/operators/OperationTimeInterval.java     | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java | 2 +-
 .../src/main/java/rx/{util => schedulers}/TimeInterval.java   | 2 +-
 .../src/main/java/rx/{util => schedulers}/Timestamped.java    | 2 +-
 .../src/test/java/rx/operators/OperationTimeIntervalTest.java | 2 +-
 .../java/rx/operators/OperatorSubscribeOnBoundedTest.java     | 2 +-
 .../src/test/java/rx/operators/OperatorTimestampTest.java     | 2 +-
 11 files changed, 12 insertions(+), 12 deletions(-)
 rename rxjava-core/src/main/java/rx/{util => schedulers}/TimeInterval.java (99%)
 rename rxjava-core/src/main/java/rx/{util => schedulers}/Timestamped.java (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 16b36eaab3..c08820511c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -116,14 +116,14 @@
 import rx.plugins.RxJavaObservableExecutionHook;
 import rx.plugins.RxJavaPlugins;
 import rx.schedulers.Schedulers;
+import rx.schedulers.TimeInterval;
+import rx.schedulers.Timestamped;
 import rx.subjects.AsyncSubject;
 import rx.subjects.BehaviorSubject;
 import rx.subjects.PublishSubject;
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.TimeInterval;
-import rx.util.Timestamped;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Action2;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
index a8e4c70042..1fc5453e1e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
@@ -32,9 +32,9 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.schedulers.Timestamped;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.Timestamped;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
 import rx.util.functions.Functions;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index c20da050a1..894a3dc473 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -28,7 +28,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.util.Timestamped;
+import rx.schedulers.Timestamped;
 
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index b4e64cf2ec..53beddd7d4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -25,7 +25,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.util.Timestamped;
+import rx.schedulers.Timestamped;
 
 /**
  * Returns an Observable that emits the last count items emitted by the source
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
index b2c67b4851..04b84044ec 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
@@ -21,7 +21,7 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
-import rx.util.TimeInterval;
+import rx.schedulers.TimeInterval;
 
 /**
  * Records the time interval between consecutive elements in an observable sequence.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java b/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
index c20e9c9ff8..a6d2a360da 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimestamp.java
@@ -18,7 +18,7 @@
 import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Subscriber;
-import rx.util.Timestamped;
+import rx.schedulers.Timestamped;
 
 /**
  * Wraps each item emitted by a source Observable in a {@link Timestamped} object.
diff --git a/rxjava-core/src/main/java/rx/util/TimeInterval.java b/rxjava-core/src/main/java/rx/schedulers/TimeInterval.java
similarity index 99%
rename from rxjava-core/src/main/java/rx/util/TimeInterval.java
rename to rxjava-core/src/main/java/rx/schedulers/TimeInterval.java
index 534ba728e9..b88896767f 100644
--- a/rxjava-core/src/main/java/rx/util/TimeInterval.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TimeInterval.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.schedulers;
 
 public class TimeInterval {
     private final long intervalInMilliseconds;
diff --git a/rxjava-core/src/main/java/rx/util/Timestamped.java b/rxjava-core/src/main/java/rx/schedulers/Timestamped.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/util/Timestamped.java
rename to rxjava-core/src/main/java/rx/schedulers/Timestamped.java
index 9ba0698070..c75da13ae8 100644
--- a/rxjava-core/src/main/java/rx/util/Timestamped.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Timestamped.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util;
+package rx.schedulers;
 
 /**
  * Composite class that takes a value and a timestamp and wraps them.
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
index 5f3c349553..e1aabf52a6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
@@ -28,8 +28,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.schedulers.TestScheduler;
+import rx.schedulers.TimeInterval;
 import rx.subjects.PublishSubject;
-import rx.util.TimeInterval;
 
 public class OperationTimeIntervalTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
index cbd94e59d7..8ee419abaf 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
@@ -37,9 +37,9 @@
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
+import rx.schedulers.Timestamped;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.Timestamped;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
index dd299d4367..a4225cee0a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
@@ -29,8 +29,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.schedulers.TestScheduler;
+import rx.schedulers.Timestamped;
 import rx.subjects.PublishSubject;
-import rx.util.Timestamped;
 
 public class OperatorTimestampTest {
     @Mock

From 8b928a8bcc0787b90cf417379710132f94fbc0f4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:55:57 -0800
Subject: [PATCH 413/441] Update sub-modules

---
 .../async/operators/OperationForEachFuture.java    |  2 +-
 rxjava-core/src/test/java/rx/ReduceTests.java      |  1 -
 .../java/rx/exceptions/CompositeExceptionTest.java |  4 ----
 .../test/java/rx/exceptions/ExceptionsTest.java    |  2 --
 .../java/rx/operators/OperatorGroupByTest.java     |  1 -
 .../java/rx/operators/OperatorObserveOnTest.java   |  5 -----
 .../test/java/rx/operators/OperatorScanTest.java   |  1 -
 .../operators/OperatorTimeoutWithSelectorTest.java | 14 +++-----------
 8 files changed, 4 insertions(+), 26 deletions(-)

diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
index bd689e204e..266c5eae40 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
@@ -20,7 +20,7 @@
 
 import rx.Observable;
 import rx.Subscription;
-import rx.util.Exceptions;
+import rx.exceptions.Exceptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 63cce95c2f..4f26939873 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -21,7 +21,6 @@
 
 import rx.CovarianceTest.HorrorMovie;
 import rx.CovarianceTest.Movie;
-import rx.operators.OperatorScan;
 import rx.util.functions.Func2;
 
 public class ReduceTests {
diff --git a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
index 14c4ad38f3..070fa8aaab 100644
--- a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -23,10 +23,6 @@
 
 import org.junit.Test;
 
-import rx.util.CompositeException.CompositeExceptionCausalChain;
-
-import rx.exceptions.CompositeException;
-
 public class CompositeExceptionTest {
 
     private final Throwable ex1 = new Throwable("Ex1");
diff --git a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
index 7a7c85d463..aefaf9b8dc 100644
--- a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -19,8 +19,6 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.exceptions.OnErrorNotImplimport rx.util.OnErrorNotImplementedException;
-ementedException;
 import rx.subjects.PublishSubject;
 import rx.util.functions.Action1;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 7d4d98aace..67617cb827 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -28,7 +28,6 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
 import rx.Observable;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index f02970118c..1a463ea71e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -30,15 +30,10 @@
 import org.mockito.stubbing.Answer;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Subscription;
-import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
-import rx.schedulers.TrampolineScheduler;
-import rx.subscriptions.BooleanSubscription;
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
index 0a653af315..1975b92b78 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
@@ -17,7 +17,6 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperatorScan.*;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 709a82caa3..3c0e874174 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -15,14 +15,9 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.assertFalse;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
@@ -38,13 +33,10 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Scheduler;
 import rx.Subscriber;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 

From c20c01e866a7001826c942c631166606c052e9a7 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:57:39 -0800
Subject: [PATCH 414/441] Move rx.util.functions to rx.functions

Eliminate dumping ground of rx.util
---
 .../lang/clojure/interop/DummyObservable.java |  8 +--
 .../rx/lang/groovy/examples/RxExamples.groovy |  4 +-
 .../lang/groovy/examples/VideoExample.groovy  |  2 +-
 .../rx/lang/groovy/GroovyActionWrapper.java   | 10 +--
 .../rx/lang/groovy/GroovyFunctionWrapper.java | 24 +++----
 .../lang/groovy/RxGroovyExtensionModule.java  |  4 +-
 .../groovy/rx/lang/groovy/TestParallel.groovy |  2 +-
 .../rx/lang/jruby/JRubyActionWrapper.java     | 10 +--
 .../rx/lang/jruby/JRubyFunctionWrapper.java   | 24 +++----
 .../rx/lang/scala/examples/MovieLibUsage.java |  2 +-
 .../schedulers/HandlerThreadScheduler.java    |  6 +-
 .../OperationObserveFromAndroidComponent.java |  4 +-
 .../OperatorCompoundButtonInput.java          |  4 +-
 .../rx/operators/OperatorEditTextInput.java   |  4 +-
 .../java/rx/operators/OperatorViewClick.java  |  4 +-
 ...rationObserveFromAndroidComponentTest.java |  2 +-
 .../HandlerThreadSchedulerTest.java           |  4 +-
 .../http/examples/ExampleObservableHttp.java  |  4 +-
 .../src/main/java/rx/util/async/Async.java    | 68 +++++++++----------
 .../rx/util/async/operators/Functionals.java  |  4 +-
 .../util/async/operators/LatchedObserver.java |  6 +-
 .../async/operators/OperationDeferFuture.java |  2 +-
 .../operators/OperationForEachFuture.java     |  4 +-
 .../operators/OperationFromFunctionals.java   |  6 +-
 .../async/operators/OperationStartFuture.java |  2 +-
 .../test/java/rx/util/async/AsyncTest.java    | 45 ++++++------
 .../operators/OperationDeferFutureTest.java   |  2 +-
 .../operators/OperationForEachFutureTest.java |  2 +-
 .../OperationFromFunctionalsTest.java         |  4 +-
 .../operators/OperationStartFutureTest.java   |  2 +-
 .../src/main/java/rx/Statement.java           |  2 +-
 .../rx/operators/OperationConditionals.java   |  2 +-
 .../operators/OperationConditionalsTest.java  |  2 +-
 .../java/rx/operators/DebugSubscriber.java    |  4 +-
 .../src/main/java/rx/plugins/DebugHook.java   |  8 +--
 .../src/test/java/rx/debug/DebugHookTest.java |  4 +-
 .../java/rx/observables/StringObservable.java |  4 +-
 .../java/rx/observables/SwingObservable.java  |  2 +-
 .../java/rx/schedulers/SwingScheduler.java    |  4 +-
 .../swing/sources/AbstractButtonSource.java   |  4 +-
 .../swing/sources/ComponentEventSource.java   |  6 +-
 .../java/rx/swing/sources/KeyEventSource.java |  8 +--
 .../rx/swing/sources/MouseEventSource.java    |  8 +--
 .../rx/schedulers/SwingSchedulerTest.java     |  2 +-
 rxjava-core/src/main/java/rx/Observable.java  | 34 +++++-----
 rxjava-core/src/main/java/rx/Scheduler.java   |  2 +-
 .../java/rx/{util => }/functions/Action.java  |  2 +-
 .../java/rx/{util => }/functions/Action0.java |  2 +-
 .../java/rx/{util => }/functions/Action1.java |  2 +-
 .../java/rx/{util => }/functions/Action2.java |  2 +-
 .../java/rx/{util => }/functions/Action3.java |  2 +-
 .../java/rx/{util => }/functions/Action4.java |  2 +-
 .../java/rx/{util => }/functions/Action5.java |  2 +-
 .../java/rx/{util => }/functions/Action6.java |  2 +-
 .../java/rx/{util => }/functions/Action7.java |  2 +-
 .../java/rx/{util => }/functions/Action8.java |  2 +-
 .../java/rx/{util => }/functions/Action9.java |  2 +-
 .../java/rx/{util => }/functions/ActionN.java |  2 +-
 .../java/rx/{util => }/functions/Actions.java |  2 +-
 .../java/rx/{util => }/functions/Func0.java   |  2 +-
 .../java/rx/{util => }/functions/Func1.java   |  2 +-
 .../java/rx/{util => }/functions/Func2.java   |  2 +-
 .../java/rx/{util => }/functions/Func3.java   |  2 +-
 .../java/rx/{util => }/functions/Func4.java   |  2 +-
 .../java/rx/{util => }/functions/Func5.java   |  2 +-
 .../java/rx/{util => }/functions/Func6.java   |  2 +-
 .../java/rx/{util => }/functions/Func7.java   |  2 +-
 .../java/rx/{util => }/functions/Func8.java   |  2 +-
 .../java/rx/{util => }/functions/Func9.java   |  2 +-
 .../java/rx/{util => }/functions/FuncN.java   |  2 +-
 .../rx/{util => }/functions/Function.java     |  2 +-
 .../rx/{util => }/functions/Functions.java    |  2 +-
 .../java/rx/{util => }/functions/Not.java     |  2 +-
 .../src/main/java/rx/joins/ActivePlan1.java   |  4 +-
 .../src/main/java/rx/joins/ActivePlan2.java   |  4 +-
 .../src/main/java/rx/joins/ActivePlan3.java   |  4 +-
 .../src/main/java/rx/joins/JoinObserver1.java |  2 +-
 .../src/main/java/rx/joins/Pattern1.java      |  2 +-
 .../src/main/java/rx/joins/Pattern2.java      |  2 +-
 .../src/main/java/rx/joins/Pattern3.java      |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan0.java |  2 +-
 rxjava-core/src/main/java/rx/joins/Plan1.java |  8 +--
 rxjava-core/src/main/java/rx/joins/Plan2.java | 10 +--
 rxjava-core/src/main/java/rx/joins/Plan3.java | 10 +--
 .../rx/observables/BlockingObservable.java    |  4 +-
 .../rx/observables/GroupedObservable.java     |  2 +-
 .../src/main/java/rx/observers/Observers.java |  4 +-
 .../main/java/rx/observers/Subscribers.java   |  4 +-
 .../java/rx/operators/ChunkedOperation.java   | 10 +--
 .../main/java/rx/operators/OperationAll.java  |  2 +-
 .../main/java/rx/operators/OperationAny.java  |  4 +-
 .../java/rx/operators/OperationAverage.java   |  4 +-
 .../java/rx/operators/OperationBuffer.java    |  4 +-
 .../rx/operators/OperationCombineLatest.java  | 20 +++---
 .../java/rx/operators/OperationConcat.java    |  2 +-
 .../java/rx/operators/OperationDebounce.java  |  4 +-
 .../java/rx/operators/OperationDefer.java     |  2 +-
 .../java/rx/operators/OperationDelay.java     |  6 +-
 .../java/rx/operators/OperationDistinct.java  |  6 +-
 .../OperationDistinctUntilChanged.java        |  6 +-
 .../java/rx/operators/OperationFinally.java   |  2 +-
 .../java/rx/operators/OperationFlatMap.java   |  6 +-
 .../rx/operators/OperationGroupByUntil.java   |  2 +-
 .../java/rx/operators/OperationGroupJoin.java |  4 +-
 .../java/rx/operators/OperationInterval.java  |  4 +-
 .../main/java/rx/operators/OperationJoin.java |  4 +-
 .../rx/operators/OperationJoinPatterns.java   |  4 +-
 .../java/rx/operators/OperationMinMax.java    |  4 +-
 .../java/rx/operators/OperationMulticast.java |  6 +-
 ...OperationOnErrorResumeNextViaFunction.java |  4 +-
 ...erationOnErrorResumeNextViaObservable.java |  2 +-
 .../rx/operators/OperationOnErrorReturn.java  |  4 +-
 ...ionOnExceptionResumeNextViaObservable.java |  2 +-
 .../rx/operators/OperationParallelMerge.java  |  2 +-
 .../java/rx/operators/OperationRefCount.java  |  2 +-
 .../java/rx/operators/OperationReplay.java    |  6 +-
 .../java/rx/operators/OperationRetry.java     |  2 +-
 .../java/rx/operators/OperationSample.java    |  2 +-
 .../rx/operators/OperationSequenceEqual.java  |  6 +-
 .../main/java/rx/operators/OperationSkip.java |  2 +-
 .../java/rx/operators/OperationSkipWhile.java |  4 +-
 .../main/java/rx/operators/OperationSum.java  |  2 +-
 .../java/rx/operators/OperationSwitch.java    |  2 +-
 .../java/rx/operators/OperationTakeTimed.java |  2 +-
 .../java/rx/operators/OperationTakeUntil.java |  2 +-
 .../java/rx/operators/OperationTakeWhile.java |  4 +-
 .../rx/operators/OperationThrottleFirst.java  |  2 +-
 .../java/rx/operators/OperationTimer.java     |  2 +-
 .../java/rx/operators/OperationToMap.java     |  6 +-
 .../rx/operators/OperationToMultimap.java     |  6 +-
 .../java/rx/operators/OperationUsing.java     |  4 +-
 .../java/rx/operators/OperationWindow.java    | 52 +++++++-------
 .../java/rx/operators/OperatorFilter.java     |  2 +-
 .../java/rx/operators/OperatorGroupBy.java    |  4 +-
 .../main/java/rx/operators/OperatorMap.java   |  2 +-
 .../java/rx/operators/OperatorObserveOn.java  |  2 +-
 .../operators/OperatorObserveOnBounded.java   |  4 +-
 .../java/rx/operators/OperatorParallel.java   |  2 +-
 .../java/rx/operators/OperatorRepeat.java     |  2 +-
 .../main/java/rx/operators/OperatorScan.java  |  2 +-
 .../rx/operators/OperatorSubscribeOn.java     |  2 +-
 .../operators/OperatorSubscribeOnBounded.java |  2 +-
 .../java/rx/operators/OperatorTimeout.java    |  2 +-
 .../rx/operators/OperatorTimeoutBase.java     |  4 +-
 .../OperatorTimeoutWithSelector.java          |  4 +-
 .../OperatorToObservableSortedList.java       |  2 +-
 .../rx/operators/OperatorUnsubscribeOn.java   |  4 +-
 .../main/java/rx/operators/OperatorZip.java   | 20 +++---
 .../rx/operators/OperatorZipIterable.java     |  2 +-
 .../RxJavaObservableExecutionHook.java        |  2 +-
 .../java/rx/schedulers/ExecutorScheduler.java |  2 +-
 .../rx/schedulers/ImmediateScheduler.java     |  2 +-
 .../rx/schedulers/NewThreadScheduler.java     |  2 +-
 .../java/rx/schedulers/SleepingAction.java    |  2 +-
 .../java/rx/schedulers/TestScheduler.java     |  2 +-
 .../rx/schedulers/TrampolineScheduler.java    |  2 +-
 .../main/java/rx/subjects/AsyncSubject.java   |  2 +-
 .../java/rx/subjects/BehaviorSubject.java     |  2 +-
 .../main/java/rx/subjects/PublishSubject.java |  2 +-
 .../main/java/rx/subjects/ReplaySubject.java  |  2 +-
 .../subjects/SubjectSubscriptionManager.java  |  4 +-
 .../rx/subscriptions/BooleanSubscription.java |  2 +-
 .../java/rx/subscriptions/Subscriptions.java  |  2 +-
 .../java/rx/ObservableCreatePerformance.java  |  2 +-
 .../rx/operators/ObservableBenchmark.java     |  2 +-
 .../OperatorFromIterablePerformance.java      |  2 +-
 .../rx/operators/OperatorMapPerformance.java  |  4 +-
 .../operators/OperatorMergePerformance.java   |  2 +-
 .../OperatorObserveOnPerformance.java         |  2 +-
 .../operators/OperatorRangePerformance.java   |  2 +-
 .../rx/operators/OperatorTakePerformance.java |  2 +-
 .../rx/operators/OperatorZipPerformance.java  |  4 +-
 .../rx/perf/AbstractPerformanceTester.java    |  2 +-
 .../java/rx/performance/PerformanceTest.java  |  2 +-
 .../rx/performance/TestChainPerformance.java  |  2 +-
 .../schedulers/SchedulerPerformanceTests.java |  2 +-
 .../schedulers/TestRecursionMemoryUsage.java  |  2 +-
 .../rx/subjects/SubjectPerformanceTests.java  |  2 +-
 .../CompositeSubscriptionAddRemovePerf.java   |  2 +-
 .../src/test/java/rx/CombineLatestTests.java  |  4 +-
 .../src/test/java/rx/CovarianceTest.java      |  2 +-
 rxjava-core/src/test/java/rx/EventStream.java |  2 +-
 .../src/test/java/rx/GroupByTests.java        |  4 +-
 .../src/test/java/rx/IntervalDemo.java        |  4 +-
 .../src/test/java/rx/ObservableDoOnTest.java  |  4 +-
 .../src/test/java/rx/ObservableTests.java     |  8 +--
 .../test/java/rx/ObservableWindowTests.java   |  4 +-
 rxjava-core/src/test/java/rx/ReduceTests.java |  2 +-
 .../src/test/java/rx/RefCountTests.java       |  4 +-
 rxjava-core/src/test/java/rx/ScanTests.java   |  4 +-
 rxjava-core/src/test/java/rx/ZipTests.java    |  6 +-
 .../java/rx/exceptions/ExceptionsTest.java    |  2 +-
 .../observables/BlockingObservableTest.java   |  4 +-
 .../java/rx/observers/SafeObserverTest.java   |  2 +-
 .../rx/operators/OnSubscribeRangeTest.java    |  2 +-
 .../java/rx/operators/OperationAllTest.java   |  2 +-
 .../java/rx/operators/OperationAmbTest.java   |  2 +-
 .../java/rx/operators/OperationAnyTest.java   |  2 +-
 .../rx/operators/OperationAverageTest.java    |  2 +-
 .../rx/operators/OperationBufferTest.java     |  6 +-
 .../java/rx/operators/OperationCacheTest.java |  2 +-
 .../operators/OperationCombineLatestTest.java |  6 +-
 .../rx/operators/OperationDebounceTest.java   |  4 +-
 .../java/rx/operators/OperationDeferTest.java |  2 +-
 .../java/rx/operators/OperationDelayTest.java |  4 +-
 .../rx/operators/OperationDistinctTest.java   |  2 +-
 .../OperationDistinctUntilChangedTest.java    |  2 +-
 .../rx/operators/OperationFinallyTest.java    |  2 +-
 .../OperationFirstOrDefaultTest.java          |  2 +-
 .../rx/operators/OperationFlatMapTest.java    |  6 +-
 .../operators/OperationGroupByUntilTest.java  |  6 +-
 .../rx/operators/OperationGroupJoinTest.java  |  6 +-
 .../java/rx/operators/OperationJoinTest.java  |  4 +-
 .../java/rx/operators/OperationJoinsTest.java |  8 +--
 .../java/rx/operators/OperationLastTest.java  |  2 +-
 .../rx/operators/OperationMinMaxTest.java     |  2 +-
 ...ationOnErrorResumeNextViaFunctionTest.java |  2 +-
 ...ionOnErrorResumeNextViaObservableTest.java |  2 +-
 .../operators/OperationOnErrorReturnTest.java |  2 +-
 ...nExceptionResumeNextViaObservableTest.java |  2 +-
 .../operators/OperationParallelMergeTest.java |  4 +-
 .../rx/operators/OperationReduceTest.java     |  6 +-
 .../rx/operators/OperationReplayTest.java     |  2 +-
 .../rx/operators/OperationSampleTest.java     |  2 +-
 .../OperationSequenceEqualTests.java          |  2 +-
 .../rx/operators/OperationSingleTest.java     |  2 +-
 .../rx/operators/OperationSkipWhileTest.java  |  4 +-
 .../java/rx/operators/OperationSumTest.java   |  2 +-
 .../rx/operators/OperationSwitchTest.java     |  2 +-
 .../rx/operators/OperationTakeWhileTest.java  |  4 +-
 .../operators/OperationThrottleFirstTest.java |  2 +-
 .../java/rx/operators/OperationToMapTest.java |  6 +-
 .../rx/operators/OperationToMultimapTest.java |  6 +-
 .../java/rx/operators/OperationUsingTest.java |  6 +-
 .../rx/operators/OperationWindowTest.java     |  6 +-
 .../operators/OperationZipTestCompletion.java |  2 +-
 .../rx/operators/OperatorDoOnEachTest.java    |  4 +-
 .../java/rx/operators/OperatorFilterTest.java |  2 +-
 .../rx/operators/OperatorGroupByTest.java     |  6 +-
 .../java/rx/operators/OperatorMapTest.java    |  6 +-
 .../java/rx/operators/OperatorMergeTest.java  |  4 +-
 .../OperatorObserveOnBoundedTest.java         |  6 +-
 .../rx/operators/OperatorObserveOnTest.java   |  6 +-
 .../rx/operators/OperatorParallelTest.java    |  4 +-
 .../java/rx/operators/OperatorRepeatTest.java |  2 +-
 .../java/rx/operators/OperatorScanTest.java   |  2 +-
 .../OperatorSubscribeOnBoundedTest.java       |  6 +-
 .../rx/operators/OperatorSubscribeOnTest.java |  2 +-
 .../java/rx/operators/OperatorTakeTest.java   |  4 +-
 .../OperatorTimeoutWithSelectorTest.java      |  4 +-
 .../OperatorToObservableSortedListTest.java   |  2 +-
 .../operators/OperatorUnsubscribeOnTest.java  |  4 +-
 .../rx/operators/OperatorZipIterableTest.java |  4 +-
 .../java/rx/operators/OperatorZipTest.java    | 10 +--
 .../AbstractSchedulerConcurrencyTests.java    |  6 +-
 .../rx/schedulers/AbstractSchedulerTests.java |  6 +-
 .../rx/schedulers/ExecutorSchedulerTests.java |  4 +-
 .../rx/schedulers/ImmediateSchedulerTest.java |  4 +-
 .../java/rx/schedulers/TestSchedulerTest.java |  4 +-
 .../schedulers/TrampolineSchedulerTest.java   |  4 +-
 .../java/rx/subjects/AsyncSubjectTest.java    |  2 +-
 .../java/rx/subjects/PublishSubjectTest.java  |  4 +-
 .../ReplaySubjectConcurrencyTest.java         |  2 +-
 .../MultipleAssignmentSubscriptionTest.java   |  2 +-
 .../RefCountSubscriptionTest.java             |  2 +-
 .../rx/subscriptions/SubscriptionsTest.java   |  2 +-
 .../src/test/java/rx/test/OperatorTester.java |  2 +-
 .../test/java/rx/util/AssertObservable.java   |  4 +-
 268 files changed, 582 insertions(+), 581 deletions(-)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action0.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action1.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action2.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action3.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action4.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action5.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action6.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action7.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action8.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Action9.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/ActionN.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Actions.java (99%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func0.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func1.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func2.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func3.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func4.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func5.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func6.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func7.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func8.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Func9.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/FuncN.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Function.java (96%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Functions.java (99%)
 rename rxjava-core/src/main/java/rx/{util => }/functions/Not.java (97%)

diff --git a/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java b/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
index 107c0a9053..223c068743 100644
--- a/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
+++ b/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
@@ -23,19 +23,19 @@ public String call(Object f) {
         return "Object";
     }
 
-    public String call(rx.util.functions.Func1 f) {
+    public String call(rx.functions.Func1 f) {
         return "rx.util.functions.Func1";
     }
 
-    public String call(rx.util.functions.Func2 f) {
+    public String call(rx.functions.Func2 f) {
         return "rx.util.functions.Func2";
     }
 
-    public String call(rx.util.functions.Action1 f) {
+    public String call(rx.functions.Action1 f) {
         return "rx.util.functions.Action1";
     }
 
-    public String call(rx.util.functions.Action2 f) {
+    public String call(rx.functions.Action2 f) {
         return "rx.util.functions.Action2";
     }
 
diff --git a/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/RxExamples.groovy b/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/RxExamples.groovy
index 3df7a88689..8d7eabb3d7 100644
--- a/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/RxExamples.groovy
+++ b/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/RxExamples.groovy
@@ -19,8 +19,8 @@ import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0
-import rx.util.functions.Func1;
+import rx.functions.Action0
+import rx.functions.Func1;
 
 // --------------------------------------------------
 // Hello World!
diff --git a/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/VideoExample.groovy b/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/VideoExample.groovy
index 8c1ec2392c..5323349fb1 100644
--- a/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/VideoExample.groovy
+++ b/language-adaptors/rxjava-groovy/src/examples/groovy/rx/lang/groovy/examples/VideoExample.groovy
@@ -19,7 +19,7 @@ import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
diff --git a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyActionWrapper.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyActionWrapper.java
index 24394e1db7..4c05c96b4a 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyActionWrapper.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyActionWrapper.java
@@ -16,11 +16,11 @@
 package rx.lang.groovy;
 
 import groovy.lang.Closure;
-import rx.util.functions.Action;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Action3;
+import rx.functions.Action;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Action3;
 
 /**
  * Concrete wrapper that accepts a {@link Closure} and produces any needed Rx {@link Action}.
diff --git a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyFunctionWrapper.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyFunctionWrapper.java
index 9937ae1a9a..4adb8de014 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyFunctionWrapper.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyFunctionWrapper.java
@@ -16,18 +16,18 @@
 package rx.lang.groovy;
 
 import groovy.lang.Closure;
-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;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+import rx.functions.Function;
 
 /**
  * Concrete wrapper that accepts a {@link Closure} and produces any needed Rx {@link Function}.
diff --git a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyExtensionModule.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyExtensionModule.java
index e4c1734bee..8f12c8430b 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyExtensionModule.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyExtensionModule.java
@@ -29,9 +29,9 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
+import rx.functions.Action;
+import rx.functions.Function;
 import rx.observables.BlockingObservable;
-import rx.util.functions.Action;
-import rx.util.functions.Function;
 
 /**
  * ExtensionModule that adds extension methods to support groovy.lang.Closure
diff --git a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy
index a54241b160..414a992392 100644
--- a/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy
+++ b/language-adaptors/rxjava-groovy/src/test/groovy/rx/lang/groovy/TestParallel.groovy
@@ -20,7 +20,7 @@ import org.junit.Test
 import rx.Observable
 import rx.Scheduler
 import rx.schedulers.Schedulers
-import rx.util.functions.Func1
+import rx.functions.Func1
 
 class TestParallel {
 
diff --git a/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyActionWrapper.java b/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyActionWrapper.java
index 5916490070..d85ffbbf41 100644
--- a/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyActionWrapper.java
+++ b/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyActionWrapper.java
@@ -21,11 +21,11 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-import rx.util.functions.Action;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Action3;
+import rx.functions.Action;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Action3;
 
 /**
  * Concrete wrapper that accepts a {@link RubyProc} and produces any needed Rx {@link Action}.
diff --git a/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyFunctionWrapper.java b/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyFunctionWrapper.java
index 38e6a193b1..d372ee136a 100644
--- a/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyFunctionWrapper.java
+++ b/language-adaptors/rxjava-jruby/src/main/java/rx/lang/jruby/JRubyFunctionWrapper.java
@@ -21,18 +21,18 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-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;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+import rx.functions.Function;
 
 /**
  * Concrete wrapper that accepts a {@link RubyProc} and produces any needed Rx {@link Function}.
diff --git a/language-adaptors/rxjava-scala/src/examples/java/rx/lang/scala/examples/MovieLibUsage.java b/language-adaptors/rxjava-scala/src/examples/java/rx/lang/scala/examples/MovieLibUsage.java
index e9b3f6be64..a8edadaf6b 100644
--- a/language-adaptors/rxjava-scala/src/examples/java/rx/lang/scala/examples/MovieLibUsage.java
+++ b/language-adaptors/rxjava-scala/src/examples/java/rx/lang/scala/examples/MovieLibUsage.java
@@ -16,9 +16,9 @@
 package rx.lang.scala.examples;
 
 import rx.Observable;
+import rx.functions.Action1;
 import rx.lang.scala.examples.Movie;
 import rx.lang.scala.examples.MovieLib;
-import rx.util.functions.Action1;
 import static rx.lang.scala.JavaConversions.toScalaObservable;
 
 public class MovieLibUsage {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
index 6f7cab027b..9bfa548880 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/schedulers/HandlerThreadScheduler.java
@@ -19,8 +19,8 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 import android.os.Handler;
 
 /**
@@ -41,9 +41,9 @@ public HandlerThreadScheduler(Handler handler) {
     }
 
     /**
-     * Calls {@link HandlerThreadScheduler#schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)} with a delay of zero milliseconds.
+     * Calls {@link HandlerThreadScheduler#schedule(Object, rx.functions.Func2, long, java.util.concurrent.TimeUnit)} with a delay of zero milliseconds.
      * 
-     * See {@link #schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)}
+     * See {@link #schedule(Object, rx.functions.Func2, long, java.util.concurrent.TimeUnit)}
      */
     @Override
     public Subscription schedule(Action1 action) {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
index f0dca7d2f9..dba31a954b 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
@@ -20,9 +20,9 @@
 import rx.Subscription;
 import rx.Scheduler.Inner;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import android.app.Activity;
 import android.os.Looper;
 import android.util.Log;
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
index f409410e4c..63687f440e 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
@@ -26,9 +26,9 @@
 import rx.Scheduler.Inner;
 import rx.android.observables.ViewObservable;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import android.view.View;
 import android.widget.CompoundButton;
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
index 896fe3c7e5..1aa08f73a9 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
@@ -21,9 +21,9 @@
 import rx.Scheduler.Inner;
 import rx.android.observables.ViewObservable;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import android.text.Editable;
 import android.text.TextWatcher;
 import android.widget.EditText;
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
index b6ea615a13..086fb53a40 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
@@ -26,9 +26,9 @@
 import rx.Subscription;
 import rx.android.observables.ViewObservable;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import android.view.View;
 
 public final class OperatorViewClick implements Observable.OnSubscribe {
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
index 0304ef3edd..e19dda4482 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
@@ -42,13 +42,13 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.operators.OperationObserveFromAndroidComponent;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 import android.app.Activity;
 import android.app.Fragment;
 
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
index af1ac21222..73cde11caa 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
@@ -29,8 +29,8 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func2;
+import rx.functions.Action1;
+import rx.functions.Func2;
 import android.os.Handler;
 
 @RunWith(RobolectricTestRunner.class)
diff --git a/rxjava-contrib/rxjava-apache-http/src/test/java/rx/apache/http/examples/ExampleObservableHttp.java b/rxjava-contrib/rxjava-apache-http/src/test/java/rx/apache/http/examples/ExampleObservableHttp.java
index 4fe7e0549a..37fe6e8925 100644
--- a/rxjava-contrib/rxjava-apache-http/src/test/java/rx/apache/http/examples/ExampleObservableHttp.java
+++ b/rxjava-contrib/rxjava-apache-http/src/test/java/rx/apache/http/examples/ExampleObservableHttp.java
@@ -26,8 +26,8 @@
 import rx.Observable;
 import rx.apache.http.ObservableHttp;
 import rx.apache.http.ObservableHttpResponse;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class ExampleObservableHttp {
 
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
index 4f04f5fb47..4559032877 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/Async.java
@@ -25,6 +25,29 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Action3;
+import rx.functions.Action4;
+import rx.functions.Action5;
+import rx.functions.Action6;
+import rx.functions.Action7;
+import rx.functions.Action8;
+import rx.functions.Action9;
+import rx.functions.ActionN;
+import rx.functions.Actions;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
 import rx.schedulers.Schedulers;
 import rx.subjects.AsyncSubject;
 import rx.subjects.PublishSubject;
@@ -35,29 +58,6 @@
 import rx.util.async.operators.OperationForEachFuture;
 import rx.util.async.operators.OperationFromFunctionals;
 import rx.util.async.operators.OperationStartFuture;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Action3;
-import rx.util.functions.Action4;
-import rx.util.functions.Action5;
-import rx.util.functions.Action6;
-import rx.util.functions.Action7;
-import rx.util.functions.Action8;
-import rx.util.functions.Action9;
-import rx.util.functions.ActionN;
-import rx.util.functions.Actions;
-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;
 
 /**
  * Utility methods to convert functions and actions into asynchronous operations
@@ -1340,7 +1340,7 @@ public static  FuncN> asyncFunc(final FuncN func,
      * @param  the result type
      * @param functionAsync the asynchronous function to run
      * @return an Observable that surfaces the result of the future
-     * @see #startFuture(rx.util.functions.Func0, rx.Scheduler)
+     * @see #startFuture(rx.functions.Func0, rx.Scheduler)
      * @see RxJava Wiki: startFuture()
      */
     public static  Observable startFuture(Func0> functionAsync) {
@@ -1379,7 +1379,7 @@ public static  Observable startFuture(Func0>
      *                               observer
      * @return the Observable emitting items produced by the asynchronous
      *         observer produced by the factory
-     * @see #deferFuture(rx.util.functions.Func0, rx.Scheduler)
+     * @see #deferFuture(rx.functions.Func0, rx.Scheduler)
      * @see RxJava Wiki: deferFuture()
      */
     public static  Observable deferFuture(Func0>> observableFactoryAsync) {
@@ -1420,7 +1420,7 @@ public static  Observable deferFuture(
      * @param source the source Observable
      * @param onNext the action to call with each emitted element
      * @return the Future representing the entire for-each operation
-     * @see #forEachFuture(rx.util.functions.Action1, rx.Scheduler)
+     * @see #forEachFuture(rx.functions.Action1, rx.Scheduler)
      * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
@@ -1444,7 +1444,7 @@ public static  FutureTask forEachFuture(
      * @param onNext the action to call with each emitted element
      * @param onError the action to call when an exception is emitted
      * @return the Future representing the entire for-each operation
-     * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.Scheduler)
+     * @see #forEachFuture(rx.functions.Action1, rx.functions.Action1, rx.Scheduler)
      * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
@@ -1470,7 +1470,7 @@ public static  FutureTask forEachFuture(
      * @param onError the action to call when an exception is emitted
      * @param onCompleted the action to call when the source completes
      * @return the Future representing the entire for-each operation
-     * @see #forEachFuture(rx.util.functions.Action1, rx.util.functions.Action1, rx.util.functions.Action0, rx.Scheduler)
+     * @see #forEachFuture(rx.functions.Action1, rx.functions.Action1, rx.functions.Action0, rx.Scheduler)
      * @see RxJava Wiki: forEachFuture()
      */
     public static  FutureTask forEachFuture(
@@ -1593,7 +1593,7 @@ public static  Observable fromAction(Action0 action, R result) {
      * @param function the function to call on each subscription
      * @return an Observable that calls the given function and emits its
      *         result when an Observer subscribes
-     * @see #start(rx.util.functions.Func0) 
+     * @see #start(rx.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      * @see RxJava Wiki: fromFunc0()
      */
@@ -1613,8 +1613,8 @@ public static  Observable fromFunc0(Func0 function) {
      * @param callable the callable to call on each subscription
      * @return an Observable that calls the given Callable and emits its
      *         result or Exception when an Observer subscribes
-     * @see #start(rx.util.functions.Func0) 
-     * @see #fromFunc0(rx.util.functions.Func0) 
+     * @see #start(rx.functions.Func0) 
+     * @see #fromFunc0(rx.functions.Func0) 
      * @see RxJava Wiki: fromCallable()
      */
     public static  Observable fromCallable(Callable callable) {
@@ -1671,7 +1671,7 @@ public static  Observable fromAction(Action0 action, R result, Scheduler s
      *                  result is emitted
      * @return an Observable that calls the given function and emits its
      *         result when an Observer subscribes
-     * @see #start(rx.util.functions.Func0) 
+     * @see #start(rx.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      * @see RxJava Wiki: fromFunc0()
      */
@@ -1691,8 +1691,8 @@ public static  Observable fromFunc0(Func0 function, Scheduler
      *                  result is emitted
      * @return an Observable that calls the given Callable and emits its
      *         result or Exception when an Observer subscribes
-     * @see #start(rx.util.functions.Func0) 
-     * @see #fromFunc0(rx.util.functions.Func0) 
+     * @see #start(rx.functions.Func0) 
+     * @see #fromFunc0(rx.functions.Func0) 
      * @see RxJava Wiki: fromCallable()
      */
     public static  Observable fromCallable(Callable callable, Scheduler scheduler) {
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
index fa06825c03..037c7b8573 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/Functionals.java
@@ -17,8 +17,8 @@
 package rx.util.async.operators;
 
 import rx.Scheduler.Inner;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 /**
  * Utility methods convert between functional interfaces of actions and functions.
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
index e76a391d87..e06dc97cfd 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/LatchedObserver.java
@@ -20,9 +20,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observer;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
 
 /**
  * An observer implementation that calls a CountDownLatch in case
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
index 8c55816fd7..a4fde509d9 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
@@ -19,7 +19,7 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.util.functions.Func0;
+import rx.functions.Func0;
 
 /**
  * Defer the execution of a factory method which produces an observable sequence.
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
index 266c5eae40..42be310d36 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
@@ -21,8 +21,8 @@
 import rx.Observable;
 import rx.Subscription;
 import rx.exceptions.Exceptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 /**
  * Convert the observation of a source observable to a big Future call.
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
index dd74f89bfd..bf890c3903 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
@@ -20,10 +20,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Actions;
+import rx.functions.Func0;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Actions;
-import rx.util.functions.Func0;
 
 /**
  * Operators that invoke a function or action if
diff --git a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
index 4f1c4005e7..3cb0e434f9 100644
--- a/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
+++ b/rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
@@ -34,7 +34,7 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.util.functions.Func0;
+import rx.functions.Func0;
 
 /**
  * Start an asynchronous Future immediately and observe its result through
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
index 3146681c5f..aead8ef078 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/AsyncTest.java
@@ -17,6 +17,7 @@
 package rx.util.async;
 
 import java.util.concurrent.CountDownLatch;
+
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
@@ -36,31 +37,31 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Action3;
+import rx.functions.Action4;
+import rx.functions.Action5;
+import rx.functions.Action6;
+import rx.functions.Action7;
+import rx.functions.Action8;
+import rx.functions.Action9;
+import rx.functions.ActionN;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
 import rx.observers.TestObserver;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Action3;
-import rx.util.functions.Action4;
-import rx.util.functions.Action5;
-import rx.util.functions.Action6;
-import rx.util.functions.Action7;
-import rx.util.functions.Action8;
-import rx.util.functions.Action9;
-import rx.util.functions.ActionN;
-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;
 
 public class AsyncTest {
     @Mock
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
index 298ffa7e02..f2d6091c96 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
@@ -31,9 +31,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func0;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
-import rx.util.functions.Func0;
 
 public class OperationDeferFutureTest {
     @Test
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
index 954380cd7e..8fd6e4c91e 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
@@ -43,9 +43,9 @@
 import org.junit.Test;
 
 import rx.Observable;
+import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
-import rx.util.functions.Action1;
 
 public class OperationForEachFutureTest {
     @Test
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
index 09c3b353d4..7580670d8a 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
@@ -32,11 +32,11 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Action0;
+import rx.functions.Func0;
 import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.util.async.Async;
-import rx.util.functions.Action0;
-import rx.util.functions.Func0;
 
 public class OperationFromFunctionalsTest {
     TestScheduler scheduler;
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
index 7086f5002e..babee1c7ac 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
@@ -31,9 +31,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func0;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
-import rx.util.functions.Func0;
 
 public class OperationStartFutureTest {
     /** Custom exception to distinguish from any other RuntimeException. */
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
index d58c047b6d..4064750139 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/Statement.java
@@ -17,8 +17,8 @@
 
 import java.util.Map;
 
+import rx.functions.Func0;
 import rx.operators.OperationConditionals;
-import rx.util.functions.Func0;
 
 /**
  * Imperative statements expressed as Observable operators.
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
index e7336b3ce5..902d202727 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
@@ -21,9 +21,9 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
 import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
 
 /**
  * Implementation of conditional-based operations such as Case, If, DoWhile and While.
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
index 35d40e7999..f96d28bd09 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
@@ -33,10 +33,10 @@
 import rx.Observer;
 import rx.Statement;
 import rx.Subscription;
+import rx.functions.Func0;
 import rx.observers.TestObserver;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
-import rx.util.functions.Func0;
 
 public class OperationConditionalsTest {
     @Mock
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
index 01de861b04..276e245e74 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscriber.java
@@ -3,9 +3,9 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.plugins.DebugNotification;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public final class DebugSubscriber extends Subscriber {
     private final Func1 onNextHook;
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
index f52d5f945c..31d54d87ce 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugHook.java
@@ -5,11 +5,11 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Actions;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.operators.DebugSubscriber;
-import rx.util.functions.Action1;
-import rx.util.functions.Actions;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Implements hooks into the {@link Observable} chain to emit a detailed account of all the events
diff --git a/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
index e90de3c11f..5a113ffc73 100644
--- a/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
+++ b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
@@ -15,12 +15,12 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.plugins.DebugHook;
 import rx.plugins.DebugNotification;
 import rx.plugins.PlugReset;
 import rx.plugins.RxJavaPlugins;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class DebugHookTest {
     @Before
diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
index df96b64473..9f55e5bb2e 100644
--- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
+++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
@@ -33,8 +33,8 @@
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 public class StringObservable {
     public static Observable from(final InputStream i) {
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
index 12200e7054..3f859d5365 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
@@ -27,11 +27,11 @@
 import javax.swing.AbstractButton;
 
 import rx.Observable;
+import rx.functions.Func1;
 import rx.swing.sources.AbstractButtonSource;
 import rx.swing.sources.ComponentEventSource;
 import rx.swing.sources.KeyEventSource;
 import rx.swing.sources.MouseEventSource;
-import rx.util.functions.Func1;
 
 /**
  * Allows creating observables from various sources specific to Swing. 
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java
index abdb34be65..1854db762b 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java
@@ -25,10 +25,10 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 /**
  * Executes work on the Swing UI thread.
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
index ef5c7db50a..2c4d7bdad0 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
@@ -29,9 +29,9 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 public enum AbstractButtonSource { ; // no instances
 
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
index 189b02b7a9..7ba8bf43c5 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
@@ -26,10 +26,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.observables.SwingObservable;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
 
 public enum ComponentEventSource { ; // no instances
 
@@ -88,7 +88,7 @@ public Dimension call(ComponentEvent event) {
     /**
      * Predicates that help with filtering observables for specific component events. 
      */
-    public enum Predicate implements rx.util.functions.Func1 { 
+    public enum Predicate implements rx.functions.Func1 { 
         RESIZED(ComponentEvent.COMPONENT_RESIZED),
         HIDDEN(ComponentEvent.COMPONENT_HIDDEN),
         MOVED(ComponentEvent.COMPONENT_MOVED),
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
index e3b37a7868..a56c244ad5 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
@@ -35,11 +35,11 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public enum KeyEventSource { ; // no instances
 
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
index ebf5e5cd62..5a26e57251 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
@@ -33,11 +33,11 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public enum MouseEventSource { ; // no instances
 
diff --git a/rxjava-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java b/rxjava-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java
index 70008fab34..afe6951e5b 100644
--- a/rxjava-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java
+++ b/rxjava-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java
@@ -32,7 +32,7 @@
 
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Executes work on the Swing UI thread.
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c08820511c..08a826b0d6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -12,7 +12,7 @@
  */
 package rx;
 
-import static rx.util.functions.Functions.*;
+import static rx.functions.Functions.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -26,6 +26,22 @@
 
 import rx.exceptions.Exceptions;
 import rx.exceptions.OnErrorNotImplementedException;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+import rx.functions.Function;
+import rx.functions.Functions;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
 import rx.observables.BlockingObservable;
@@ -124,22 +140,6 @@
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-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;
-import rx.util.functions.Functions;
 
 /**
  * The Observable class that implements the Reactive Pattern.
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 29d5e70f99..fee78c57dd 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -17,7 +17,7 @@
 
 import java.util.concurrent.TimeUnit;
 
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Represents an object that schedules units of work.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action.java b/rxjava-core/src/main/java/rx/functions/Action.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action.java
rename to rxjava-core/src/main/java/rx/functions/Action.java
index e17377925e..277533e325 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action.java
+++ b/rxjava-core/src/main/java/rx/functions/Action.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * All Action interfaces extend from this.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action0.java b/rxjava-core/src/main/java/rx/functions/Action0.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action0.java
rename to rxjava-core/src/main/java/rx/functions/Action0.java
index d700124291..2a79857f18 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action0.java
+++ b/rxjava-core/src/main/java/rx/functions/Action0.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Action0 extends Action {
     public void call();
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action1.java b/rxjava-core/src/main/java/rx/functions/Action1.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action1.java
rename to rxjava-core/src/main/java/rx/functions/Action1.java
index 37ec755968..588cd9e66f 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action1.java
+++ b/rxjava-core/src/main/java/rx/functions/Action1.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Action1 extends Action {
     public void call(T1 t1);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action2.java b/rxjava-core/src/main/java/rx/functions/Action2.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action2.java
rename to rxjava-core/src/main/java/rx/functions/Action2.java
index 62c75eadd5..370c4650cf 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action2.java
+++ b/rxjava-core/src/main/java/rx/functions/Action2.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Action2 extends Action {
     public void call(T1 t1, T2 t2);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action3.java b/rxjava-core/src/main/java/rx/functions/Action3.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action3.java
rename to rxjava-core/src/main/java/rx/functions/Action3.java
index 34178972a2..e48e9bb92a 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action3.java
+++ b/rxjava-core/src/main/java/rx/functions/Action3.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Action3 extends Action {
     public void call(T1 t1, T2 t2, T3 t3);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action4.java b/rxjava-core/src/main/java/rx/functions/Action4.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action4.java
rename to rxjava-core/src/main/java/rx/functions/Action4.java
index a386219ec1..c0e2999bd4 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action4.java
+++ b/rxjava-core/src/main/java/rx/functions/Action4.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A four-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action5.java b/rxjava-core/src/main/java/rx/functions/Action5.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action5.java
rename to rxjava-core/src/main/java/rx/functions/Action5.java
index 4e48b485cb..78d5237e6b 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action5.java
+++ b/rxjava-core/src/main/java/rx/functions/Action5.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A five-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action6.java b/rxjava-core/src/main/java/rx/functions/Action6.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action6.java
rename to rxjava-core/src/main/java/rx/functions/Action6.java
index d3d7223493..3908969444 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action6.java
+++ b/rxjava-core/src/main/java/rx/functions/Action6.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A six-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action7.java b/rxjava-core/src/main/java/rx/functions/Action7.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action7.java
rename to rxjava-core/src/main/java/rx/functions/Action7.java
index ca299c37db..60bec4b877 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action7.java
+++ b/rxjava-core/src/main/java/rx/functions/Action7.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A seven-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action8.java b/rxjava-core/src/main/java/rx/functions/Action8.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action8.java
rename to rxjava-core/src/main/java/rx/functions/Action8.java
index 8c82fffeef..43da8ed309 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action8.java
+++ b/rxjava-core/src/main/java/rx/functions/Action8.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * An eight-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action9.java b/rxjava-core/src/main/java/rx/functions/Action9.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Action9.java
rename to rxjava-core/src/main/java/rx/functions/Action9.java
index 574f49ebe3..012fe3040c 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action9.java
+++ b/rxjava-core/src/main/java/rx/functions/Action9.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A nine-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/ActionN.java b/rxjava-core/src/main/java/rx/functions/ActionN.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/ActionN.java
rename to rxjava-core/src/main/java/rx/functions/ActionN.java
index a5f3b1c297..ccc714c341 100644
--- a/rxjava-core/src/main/java/rx/util/functions/ActionN.java
+++ b/rxjava-core/src/main/java/rx/functions/ActionN.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * A vector-argument action.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Actions.java b/rxjava-core/src/main/java/rx/functions/Actions.java
similarity index 99%
rename from rxjava-core/src/main/java/rx/util/functions/Actions.java
rename to rxjava-core/src/main/java/rx/functions/Actions.java
index 7b233bb7fb..9954ce5119 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Actions.java
+++ b/rxjava-core/src/main/java/rx/functions/Actions.java
@@ -13,7 +13,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 import rx.Observer;
 
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func0.java b/rxjava-core/src/main/java/rx/functions/Func0.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func0.java
rename to rxjava-core/src/main/java/rx/functions/Func0.java
index 21fedb1110..ee8178bb33 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func0.java
+++ b/rxjava-core/src/main/java/rx/functions/Func0.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func0 extends Function {
     public R call();
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func1.java b/rxjava-core/src/main/java/rx/functions/Func1.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func1.java
rename to rxjava-core/src/main/java/rx/functions/Func1.java
index 13d553bc0c..1f22c557c1 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func1.java
+++ b/rxjava-core/src/main/java/rx/functions/Func1.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func1 extends Function {
     public R call(T1 t1);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func2.java b/rxjava-core/src/main/java/rx/functions/Func2.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func2.java
rename to rxjava-core/src/main/java/rx/functions/Func2.java
index 9b6ffc4195..cbc6eb0515 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func2.java
+++ b/rxjava-core/src/main/java/rx/functions/Func2.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func2 extends Function {
     public R call(T1 t1, T2 t2);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func3.java b/rxjava-core/src/main/java/rx/functions/Func3.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func3.java
rename to rxjava-core/src/main/java/rx/functions/Func3.java
index 7320cbd381..7a187626ab 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func3.java
+++ b/rxjava-core/src/main/java/rx/functions/Func3.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func3 extends Function {
     public R call(T1 t1, T2 t2, T3 t3);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func4.java b/rxjava-core/src/main/java/rx/functions/Func4.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func4.java
rename to rxjava-core/src/main/java/rx/functions/Func4.java
index 5d55ae6bf7..2d37860fc0 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func4.java
+++ b/rxjava-core/src/main/java/rx/functions/Func4.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func4 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func5.java b/rxjava-core/src/main/java/rx/functions/Func5.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func5.java
rename to rxjava-core/src/main/java/rx/functions/Func5.java
index 254f361730..c2ec077dfe 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func5.java
+++ b/rxjava-core/src/main/java/rx/functions/Func5.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func5 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func6.java b/rxjava-core/src/main/java/rx/functions/Func6.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func6.java
rename to rxjava-core/src/main/java/rx/functions/Func6.java
index 4d59a40a8f..08dd563996 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func6.java
+++ b/rxjava-core/src/main/java/rx/functions/Func6.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func6 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func7.java b/rxjava-core/src/main/java/rx/functions/Func7.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func7.java
rename to rxjava-core/src/main/java/rx/functions/Func7.java
index 03c96d8359..f36cbd9c21 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func7.java
+++ b/rxjava-core/src/main/java/rx/functions/Func7.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func7 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func8.java b/rxjava-core/src/main/java/rx/functions/Func8.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func8.java
rename to rxjava-core/src/main/java/rx/functions/Func8.java
index 0df5b7d4c1..499e687183 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func8.java
+++ b/rxjava-core/src/main/java/rx/functions/Func8.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func8 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func9.java b/rxjava-core/src/main/java/rx/functions/Func9.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Func9.java
rename to rxjava-core/src/main/java/rx/functions/Func9.java
index f2db74e75a..d96731ed01 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func9.java
+++ b/rxjava-core/src/main/java/rx/functions/Func9.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface Func9 extends Function {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
diff --git a/rxjava-core/src/main/java/rx/util/functions/FuncN.java b/rxjava-core/src/main/java/rx/functions/FuncN.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/FuncN.java
rename to rxjava-core/src/main/java/rx/functions/FuncN.java
index 5e43d9217a..2d4c9d3911 100644
--- a/rxjava-core/src/main/java/rx/util/functions/FuncN.java
+++ b/rxjava-core/src/main/java/rx/functions/FuncN.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public interface FuncN extends Function {
     public R call(Object... args);
diff --git a/rxjava-core/src/main/java/rx/util/functions/Function.java b/rxjava-core/src/main/java/rx/functions/Function.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/util/functions/Function.java
rename to rxjava-core/src/main/java/rx/functions/Function.java
index 16b0bd3939..cbe7bd1a37 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Function.java
+++ b/rxjava-core/src/main/java/rx/functions/Function.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * All Func and Action interfaces extend from this.
diff --git a/rxjava-core/src/main/java/rx/util/functions/Functions.java b/rxjava-core/src/main/java/rx/functions/Functions.java
similarity index 99%
rename from rxjava-core/src/main/java/rx/util/functions/Functions.java
rename to rxjava-core/src/main/java/rx/functions/Functions.java
index 285e7e2e46..b30ad4e4d2 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Functions.java
+++ b/rxjava-core/src/main/java/rx/functions/Functions.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 public class Functions {
 
diff --git a/rxjava-core/src/main/java/rx/util/functions/Not.java b/rxjava-core/src/main/java/rx/functions/Not.java
similarity index 97%
rename from rxjava-core/src/main/java/rx/util/functions/Not.java
rename to rxjava-core/src/main/java/rx/functions/Not.java
index 7c24c0c148..da37ab473d 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Not.java
+++ b/rxjava-core/src/main/java/rx/functions/Not.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.util.functions;
+package rx.functions;
 
 /**
  * Implements the negation of a predicate.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
index 1c59c5a4bd..1595e3f6d5 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan1.java
@@ -16,8 +16,8 @@
 package rx.joins;
 
 import rx.Notification;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 /**
  * Represents an active plan.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
index 2dfc7f252e..a477e99066 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan2.java
@@ -16,8 +16,8 @@
 package rx.joins;
 
 import rx.Notification;
-import rx.util.functions.Action0;
-import rx.util.functions.Action2;
+import rx.functions.Action0;
+import rx.functions.Action2;
 
 /**
  * Represents an active plan.
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
index a905aeca6a..d0a90002e4 100644
--- a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
+++ b/rxjava-core/src/main/java/rx/joins/ActivePlan3.java
@@ -16,8 +16,8 @@
 package rx.joins;
 
 import rx.Notification;
-import rx.util.functions.Action0;
-import rx.util.functions.Action3;
+import rx.functions.Action0;
+import rx.functions.Action3;
 
 /**
  * Represents an active plan.
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index cf7125455d..2937b3e0e2 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -24,8 +24,8 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Subscriber;
+import rx.functions.Action1;
 import rx.observers.SafeSubscriber;
-import rx.util.functions.Action1;
 
 /**
  * Default implementation of a join observer.
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern1.java b/rxjava-core/src/main/java/rx/joins/Pattern1.java
index 32f73cad15..d31e388638 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern1.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern1.java
@@ -16,7 +16,7 @@
 package rx.joins;
 
 import rx.Observable;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Represents a join pattern over one observable sequence.
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern2.java b/rxjava-core/src/main/java/rx/joins/Pattern2.java
index 579717aa15..b967ad2930 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern2.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern2.java
@@ -16,7 +16,7 @@
 package rx.joins;
 
 import rx.Observable;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 /**
  * Represents a join pattern over observable sequences.
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern3.java b/rxjava-core/src/main/java/rx/joins/Pattern3.java
index d15a3cf48a..60d4daf2f8 100644
--- a/rxjava-core/src/main/java/rx/joins/Pattern3.java
+++ b/rxjava-core/src/main/java/rx/joins/Pattern3.java
@@ -16,7 +16,7 @@
 package rx.joins;
 
 import rx.Observable;
-import rx.util.functions.Func3;
+import rx.functions.Func3;
 
 /**
  * Represents a join pattern over observable sequences.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan0.java b/rxjava-core/src/main/java/rx/joins/Plan0.java
index 30a7b79197..c10d5c1be7 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan0.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan0.java
@@ -19,7 +19,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Represents an execution plan for join patterns.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan1.java b/rxjava-core/src/main/java/rx/joins/Plan1.java
index 6502ca0bed..7d1912e979 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan1.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan1.java
@@ -19,10 +19,10 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observer;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Actions;
-import rx.util.functions.Func1;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Actions;
+import rx.functions.Func1;
 
 /**
  * Represents an execution plan for join patterns.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan2.java b/rxjava-core/src/main/java/rx/joins/Plan2.java
index 59a69952fe..06495a51ca 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan2.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan2.java
@@ -19,11 +19,11 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observer;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Actions;
-import rx.util.functions.Func2;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Actions;
+import rx.functions.Func2;
 
 /**
  * Represents an execution plan for join patterns.
diff --git a/rxjava-core/src/main/java/rx/joins/Plan3.java b/rxjava-core/src/main/java/rx/joins/Plan3.java
index 8d84ea4ad1..9ed8fa4313 100644
--- a/rxjava-core/src/main/java/rx/joins/Plan3.java
+++ b/rxjava-core/src/main/java/rx/joins/Plan3.java
@@ -19,11 +19,11 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observer;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Action3;
-import rx.util.functions.Actions;
-import rx.util.functions.Func3;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Action3;
+import rx.functions.Actions;
+import rx.functions.Func3;
 
 /**
  * Represents an execution plan for join patterns.
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 23b6146356..fdd8db73ed 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -23,14 +23,14 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observers.SafeSubscriber;
 import rx.operators.OperationLatest;
 import rx.operators.OperationMostRecent;
 import rx.operators.OperationNext;
 import rx.operators.OperationToFuture;
 import rx.operators.OperationToIterator;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * An extension of {@link Observable} that provides blocking operators.
diff --git a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
index 258d751ff4..120f742e77 100644
--- a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
@@ -16,7 +16,7 @@
 package rx.observables;
 
 import rx.Observable;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * An {@link Observable} that has been grouped by a key whose value can be obtained using {@link #getKey()} 
    
diff --git a/rxjava-core/src/main/java/rx/observers/Observers.java b/rxjava-core/src/main/java/rx/observers/Observers.java
index d8e5b41f73..81c3c8330d 100644
--- a/rxjava-core/src/main/java/rx/observers/Observers.java
+++ b/rxjava-core/src/main/java/rx/observers/Observers.java
@@ -2,8 +2,8 @@
 
 import rx.Observer;
 import rx.exceptions.OnErrorNotImplementedException;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 public class Observers {
 
diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
index 07d209e36c..bc9496e3e3 100644
--- a/rxjava-core/src/main/java/rx/observers/Subscribers.java
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.java
@@ -3,8 +3,8 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.exceptions.OnErrorNotImplementedException;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 public class Subscribers {
 
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 04125acd64..74fea62687 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -29,9 +29,9 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func0;
+import rx.functions.Func1;
 
 /**
  * The base class for operations that break observables into "chunks". Currently buffers and windows.
@@ -470,7 +470,7 @@ public void stop() {
     /**
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives an
      * object from the provided {@link rx.Observable} created with the
-     * chunkClosingSelector {@link rx.util.functions.Func0}.
+     * chunkClosingSelector {@link rx.functions.Func0}.
      * 
      * @param 
      *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
@@ -516,7 +516,7 @@ public void stop() {
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives
      * an object from the provided chunkOpenings {@link rx.Observable}, and closes the corresponding {@link rx.operators.ChunkedOperation.Chunk} object when it receives an object from the provided
      * {@link rx.Observable} created
-     * with the chunkClosingSelector {@link rx.util.functions.Func1}.
+     * with the chunkClosingSelector {@link rx.functions.Func1}.
      * 
      * @param 
      *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
index 2a68c0bd71..681486f13c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAll.java
@@ -21,7 +21,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAny.java b/rxjava-core/src/main/java/rx/operators/OperationAny.java
index cb650a2bee..117e1a5437 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAny.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAny.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import static rx.util.functions.Functions.*;
+import static rx.functions.Functions.*;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -23,7 +23,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Returns an {@link Observable} that emits true if any element of
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
index 01a7ad0765..1017df4524 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
@@ -19,8 +19,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 /**
  * A few operators for implementing the averaging operation.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index 688d8afe31..b3dd33400b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -25,10 +25,10 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public final class OperationBuffer extends ChunkedOperation {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
index 9e05b1c7c4..b423045c60 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
@@ -26,17 +26,17 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+import rx.functions.Functions;
 import rx.subscriptions.CompositeSubscription;
-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.Functions;
 
 /**
  * Returns an Observable that combines the emissions of multiple source observables. Once each
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
index 9eab8085f1..6ab68f27a2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
@@ -23,8 +23,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 /**
  * Returns an Observable that emits the items emitted by two or more Observables, one after the
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 0a35a2cd3c..5a7da4a1bb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -24,12 +24,12 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observers.SynchronizedObserver;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * This operation is used to filter out bursts of events. This is done by ignoring the events from an observable which are too
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefer.java b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
index 387db931a4..95835b6b79 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
@@ -19,7 +19,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func0;
+import rx.functions.Func0;
 
 /**
  * Do not create the Observable until an Observer subscribes; create a fresh Observable on each
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 6ce3e94a00..56605429d8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -23,13 +23,13 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public final class OperationDelay {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
index 9fc8f94ffe..6c794c019a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
@@ -25,10 +25,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Returns an Observable that emits all distinct items emitted by the source.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
index b78da98f96..4760109c10 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
@@ -21,10 +21,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Returns an Observable that emits all sequentially distinct items emitted by the source.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFinally.java b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
index 0d0667f1f8..a54a2586f8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFinally.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
@@ -19,7 +19,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 /**
  * Registers an action to be called when an Observable invokes onComplete or onError.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
index 8e9c6202b4..6dd4a0a4ec 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -21,11 +21,11 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 /**
  * Additional flatMap operators.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index c6bde5ff48..ab37d3a014 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -26,12 +26,12 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func1;
 
 /**
  * Groups the elements of an observable sequence according to a specified key selector, value selector and duration selector function.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
index b32ffdf188..33f5db3848 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
@@ -24,13 +24,13 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.RefCountSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 /**
  * Corrrelates two sequences when they overlap and groups the results.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index c3936afc09..a0cd28537c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -22,10 +22,10 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 /**
  * Returns an observable sequence that produces a value after each period.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index 6211040b76..629ba9c708 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -22,10 +22,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 /**
  * Correlates the elements of two sequences based on overlapping durations.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
index 21c02fb90e..1b55cf819c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
@@ -25,14 +25,14 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.joins.ActivePlan0;
 import rx.joins.JoinObserver;
 import rx.joins.Pattern1;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * Join patterns: And, Then, When.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
index 1a4d4d757b..b6490e9ef9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
@@ -20,8 +20,8 @@
 import java.util.List;
 
 import rx.Observable;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 /**
  * Returns the minimum element in an observable sequence.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
index 903a885587..5f0803eb1e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
@@ -20,13 +20,13 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperationMulticast {
     public static  ConnectableObservable multicast(Observable source, final Subject subject) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
index 3aea40f6f0..a3f3c694bb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
@@ -23,9 +23,9 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
 
 /**
  * Instruct an Observable to pass control to another Observable (the return value of a function)
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
index 4b4d987696..a69241262a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
@@ -21,8 +21,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 /**
  * Instruct an Observable to pass control to another Observable rather than invoking
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
index 84df5272a6..de06acf78e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
@@ -23,9 +23,9 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
 
 /**
  * Instruct an Observable to emit a particular item to its Observer's onNext method
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
index 170b5d02b4..26153577b6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
@@ -21,8 +21,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 /**
  * Instruct an Observable to pass control to another Observable rather than invoking
diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
index 5ea77a50c4..b71aaf5efa 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
@@ -19,9 +19,9 @@
 
 import rx.Observable;
 import rx.Scheduler;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Func1;
 
 public class OperationParallelMerge {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
index 2c1d07ec8b..ab99ca4628 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
@@ -18,9 +18,9 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.observables.ConnectableObservable;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 /**
  * Returns an observable sequence that stays connected to the source as long
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
index 1fc5453e1e..3bfcf6beb7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
@@ -32,12 +32,12 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.schedulers.Timestamped;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Replay with limited buffer and/or time constraints.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRetry.java b/rxjava-core/src/main/java/rx/operators/OperationRetry.java
index a84ab90aac..ece2358a6c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRetry.java
@@ -38,8 +38,8 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
 
 public class OperationRetry {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
index a48c0a512a..56b5d09c5a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java
@@ -24,10 +24,10 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 /**
  * Returns an Observable that emits the results of sampling the items emitted by the source
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
index d11bcc08e4..04b4c41d17 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
@@ -18,9 +18,9 @@
 import static rx.Observable.*;
 import rx.Notification;
 import rx.Observable;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
-import rx.util.functions.Functions;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Functions;
 
 /**
  * Returns an Observable that emits a Boolean value that indicate whether two
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 2ab01d1f0f..5267322e96 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -25,8 +25,8 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action1;
 
 /**
  * Returns an Observable that skips the first num items emitted by the source
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java b/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
index 54476adb69..aaa2914986 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
@@ -22,8 +22,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 /**
  * Skips any emitted source items as long as the specified condition holds true. Emits all further source items
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
index 65d4c8e4a9..7c2177836f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSum.java
@@ -16,7 +16,7 @@
 package rx.operators;
 
 import rx.Observable;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 /**
  * A few operators for implementing the sum operation.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index c6fc01d5af..332e1090a9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -19,9 +19,9 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func1;
 
 /**
  * Transforms an Observable that emits Observables into a single Observable that
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index 42ba12d697..88fd652026 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -24,9 +24,9 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 /**
  * Returns an Observable that emits the first num items emitted by the source
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
index e06381afab..fd3615b8b5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
@@ -19,7 +19,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Returns an Observable that emits the items from the source Observable until another Observable
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
index 219295d626..b2b7748991 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
@@ -21,8 +21,8 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 /**
  * Returns an Observable that emits items emitted by the source Observable as long as a specified
diff --git a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
index b942065c48..44d2d02083 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
@@ -23,8 +23,8 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Func1;
 
 /**
  * Throttle by windowing a stream and returning the first value in each window.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 36024bdabb..16f745129f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -22,7 +22,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Operation Timer with several overloads.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
index e15c180aec..5e346f1ddd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
@@ -23,10 +23,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Maps the elements of the source observable into a java.util.Map instance and
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
index a04c3545cb..94900abeda 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
@@ -25,10 +25,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * Maps the elements of the source observable into a multimap
diff --git a/rxjava-core/src/main/java/rx/operators/OperationUsing.java b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
index 6476c03745..15108481f4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationUsing.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
@@ -19,10 +19,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 /**
  * Constructs an observable sequence that depends on a resource object.
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index eae1f059ef..c0d96f3a79 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -22,13 +22,13 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public final class OperationWindow extends ChunkedOperation {
 
@@ -42,11 +42,11 @@ public Window call() {
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
-     * values from the specified {@link rx.Observable} source and stores them in a window until the {@link rx.Observable} constructed using the {@link rx.util.functions.Func0} argument, produces a
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window until the {@link rx.Observable} constructed using the {@link rx.functions.Func0} argument, produces a
      * value. The window is then
      * emitted, and a new window is created to replace it. A new {@link rx.Observable} will be constructed using the
-     * provided {@link rx.util.functions.Func0} object, which will determine when this new window is emitted. When the source {@link rx.Observable} completes or produces an error, the current window
+     * provided {@link rx.functions.Func0} object, which will determine when this new window is emitted. When the source {@link rx.Observable} completes or produces an error, the current window
      * is emitted, and the event is propagated
      * to all subscribed {@link rx.Observer}s.
    
      * 
@@ -56,10 +56,10 @@ public Window call() {
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param windowClosingSelector
-     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            A {@link rx.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
      *            producing an object.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final Func0> windowClosingSelector) {
         return new OnSubscribeFunc>() {
@@ -74,7 +74,7 @@ public Subscription onSubscribe(final Observer> observer)
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in the currently active window. Initially
      * there are no windows active.
    
      * 
@@ -93,10 +93,10 @@ public Subscription onSubscribe(final Observer> observer)
      *            An {@link rx.Observable} which when it produces a {@link rx.util.Opening} value will
      *            create a new window which instantly starts recording the "source" {@link rx.Observable}.
      * @param windowClosingSelector
-     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            A {@link rx.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
      *            producing an object.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final Observable windowOpenings, final Func1> windowClosingSelector) {
         return new OnSubscribeFunc>() {
@@ -110,7 +110,7 @@ public Subscription onSubscribe(final Observer> observer)
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window until the window contains
      * a specified number of elements. The window is then emitted, and a new window is created to replace it.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
@@ -124,14 +124,14 @@ public Subscription onSubscribe(final Observer> observer)
      * @param count
      *            The number of elements a window should have before being emitted and replaced.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(Observable source, int count) {
         return window(source, count, count);
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in all active windows until the window
      * contains a specified number of elements. The window is then emitted. windows are created after a certain
      * amount of values have been received. When the source {@link rx.Observable} completes or produces an error, the
@@ -151,7 +151,7 @@ public static  OnSubscribeFunc> window(Observable
      *            > "count" non-overlapping windows will be created and some values will not be pushed
      *            into a window at all!
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final int count, final int skip) {
         return new OnSubscribeFunc>() {
@@ -165,7 +165,7 @@ public Subscription onSubscribe(final Observer> observer)
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
@@ -181,14 +181,14 @@ public Subscription onSubscribe(final Observer> observer)
      * @param unit
      *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(Observable source, long timespan, TimeUnit unit) {
         return window(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
@@ -206,7 +206,7 @@ public static  OnSubscribeFunc> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc>() {
@@ -220,7 +220,7 @@ public Subscription onSubscribe(final Observer> observer)
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * Additionally the window is automatically emitted once it reaches a specified number of elements.
@@ -239,14 +239,14 @@ public Subscription onSubscribe(final Observer> observer)
      * @param count
      *            The maximum size of the window. Once a window reaches this size, it is emitted.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(Observable source, long timespan, TimeUnit unit, int count) {
         return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * Additionally the window is automatically emitted once it reaches a specified number of elements.
@@ -267,7 +267,7 @@ public static  OnSubscribeFunc> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
         return new OnSubscribeFunc>() {
@@ -281,7 +281,7 @@ public Subscription onSubscribe(final Observer> observer)
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
@@ -300,14 +300,14 @@ public Subscription onSubscribe(final Observer> observer)
      * @param unit
      *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(Observable source, long timespan, long timeshift, TimeUnit unit) {
         return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * 
    This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * 
    This method creates a {@link rx.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
@@ -328,7 +328,7 @@ public static  OnSubscribeFunc> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation.
      */
     public static  OnSubscribeFunc> window(final Observable source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc>() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index a6e8850f2b..6b46148147 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -17,8 +17,8 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
-import rx.util.functions.Func1;
 
 /**
  * Filters an Observable by discarding any items it emits that do not meet some test.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 7b99bddd72..6279cd92d5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -23,13 +23,13 @@
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
 
 /**
  * Groups the items emitted by an Observable according to a specified criterion, and emits these
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index 89845162ab..efb09bae01 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -17,7 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Applies a function of your choosing to every item emitted by an Observable, and returns this
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index c963bf3783..c2457dd8d2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -22,9 +22,9 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.functions.Action1;
 import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.TrampolineScheduler;
-import rx.util.functions.Action1;
 
 /**
  * Delivers events on the specified Scheduler asynchronously via an unbounded buffer.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
index 740f8fdad4..97c53ae431 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
@@ -22,12 +22,12 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 /**
  * Delivers events on the specified Scheduler.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
index 38559e0500..d5ef638fcd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
@@ -19,8 +19,8 @@
 import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Subscriber;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
-import rx.util.functions.Func1;
 
 /**
  * Identifies unit of work that can be executed in parallel on a given Scheduler.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index d4cbaea5be..d587aa8a6b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -21,9 +21,9 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.functions.Action1;
 import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
 
 public class OperatorRepeat implements Operator> {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
index c3b4a3d22d..1428f25225 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -17,7 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 /**
  * Returns an Observable that applies a function to the first item emitted by a source Observable,
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 0c49a38162..d549c146c2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -20,7 +20,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Subscribes Observers on the specified Scheduler.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
index 284cfcc5bd..969f0df8b9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
@@ -20,7 +20,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Subscribes and unsubscribes Observers on the specified Scheduler.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
index 7a1c0cf835..eb5debfcd5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
@@ -21,7 +21,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Applies a timeout policy for each element in the observable sequence, using
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index f9ba9efc77..3d6dc97998 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -23,10 +23,10 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Func2;
+import rx.functions.Func3;
 import rx.observers.SynchronizedSubscriber;
 import rx.subscriptions.SerialSubscription;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
 
 class OperatorTimeoutBase implements Operator {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index 3932bd94f5..ffc79f749b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -19,9 +19,9 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.Exceptions;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 /**
  * Returns an Observable that mirrors the source Observable. If either the first
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java b/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
index f6ddb106ba..fa1c931ca5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToObservableSortedList.java
@@ -22,7 +22,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 /**
  * Return an Observable that emits the items emitted by the source Observable, in a sorted order
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
index 0d734c5f73..c48e0bc69f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
@@ -19,11 +19,11 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 /**
  * Unsubscribes on the specified Scheduler.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 8b625b01b6..ad560d713b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -22,17 +22,17 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+import rx.functions.Functions;
 import rx.subscriptions.CompositeSubscription;
-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.Functions;
 
 /**
  * Returns an Observable that emits the results of a function applied to sets of items emitted, in
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
index 4bf60973b9..05f2a47c82 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZipIterable.java
@@ -19,8 +19,8 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.functions.Func2;
 import rx.observers.Subscribers;
-import rx.util.functions.Func2;
 
 public final class OperatorZipIterable implements Operator {
 
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 2c1c3f67e9..5668a1b416 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -21,7 +21,7 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 /**
  * Abstract ExecutionHook with invocations at different lifecycle points of {@link Observable} execution with a default no-op implementation.
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index b0c0607456..ed5006aa22 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -24,9 +24,9 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 /**
  * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService} implementation.
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index 810123b3ce..eca1a2f5d7 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -19,8 +19,8 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 
 /**
  * Executes work immediately on the current thread.
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 00639b93c0..96db3f7bcf 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -25,9 +25,9 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 /**
  * Schedules work on a new thread.
diff --git a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
index ec87050336..cd4a39e046 100644
--- a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
+++ b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
@@ -17,7 +17,7 @@
 
 import rx.Scheduler;
 import rx.Scheduler.Inner;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /* package */class SleepingAction implements Action1 {
     private final Action1 underlying;
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index a858a93ccb..2bb9a11d40 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -22,8 +22,8 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 
 public class TestScheduler extends Scheduler {
     private final Queue queue = new PriorityQueue(11, new CompareActionsByTime());
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index 0e0e8ccd0f..2539fe4d4a 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -21,8 +21,8 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 
 /**
  * Schedules work on the current thread but does not execute immediately. Work is put in a queue and executed after the current unit of work is completed.
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 16eeeb0bc6..268628b013 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -20,8 +20,8 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
-import rx.util.functions.Action1;
 
 /**
  * Subject that publishes only the last event to each {@link Observer} that has subscribed when the
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 3c1cdaa433..5e33a85637 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -20,8 +20,8 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
-import rx.util.functions.Action1;
 
 /**
  * Subject that publishes the most recent and all subsequent events to each subscribed {@link Observer}.
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 9a78f17a93..8cc484a36e 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -20,8 +20,8 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
-import rx.util.functions.Action1;
 
 /**
  * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 0b30987b09..264747d7f4 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -23,8 +23,8 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
-import rx.util.functions.Action1;
 
 /**
  * Subject that retains all events and will replay them to an {@link Observer} that subscribes.
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 970e2dcdf8..0524100659 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -24,10 +24,10 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.operators.SafeObservableSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 /* package */class SubjectSubscriptionManager {
 
diff --git a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
index fa7af6a8a6..8e305fd1a4 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/BooleanSubscription.java
@@ -19,7 +19,7 @@
 
 import rx.Observable;
 import rx.Subscription;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 /**
  * Subscription that can be checked for status such as in a loop inside an {@link Observable} to exit the loop if unsubscribed.
diff --git a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
index 6499967f65..ec3f3c824b 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
@@ -18,8 +18,8 @@
 import java.util.concurrent.Future;
 
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.operators.SafeObservableSubscription;
-import rx.util.functions.Action0;
 
 /**
  * Helper methods and utilities for creating and working with {@link Subscription} objects
diff --git a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java b/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
index 6e892a324b..845cfeb412 100644
--- a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
+++ b/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
@@ -1,9 +1,9 @@
 package rx;
 
 import rx.Observable.OnSubscribe;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.LongSumObserver;
-import rx.util.functions.Action0;
 
 public class ObservableCreatePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
index 432c8ac6e1..9602cb797d 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -14,7 +14,7 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class ObservableBenchmark {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
index ea3f2c18c3..522dc15351 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
@@ -4,10 +4,10 @@
 import java.util.Iterator;
 
 import rx.Observable;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
 import rx.perf.LongSumObserver;
-import rx.util.functions.Action0;
 
 public class OperatorFromIterablePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
index dc85a1d6e6..b40aa72dd5 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
@@ -1,10 +1,10 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.LongSumObserver;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
 
 public class OperatorMapPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
index 99ce4deac9..ee3713baf6 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
@@ -1,11 +1,11 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
 import rx.perf.LongSumObserver;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action0;
 
 public class OperatorMergePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
index 4a28e85d6d..c892fe493b 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
@@ -1,10 +1,10 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action0;
 
 public class OperatorObserveOnPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
index 5004ccc132..034342c183 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
@@ -1,9 +1,9 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
-import rx.util.functions.Action0;
 
 public class OperatorRangePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
index 3e8e8be702..6e28f51545 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
@@ -1,9 +1,9 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
-import rx.util.functions.Action0;
 
 public class OperatorTakePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
index 0d929b6a33..aa2c071560 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
@@ -1,10 +1,10 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.functions.Action0;
+import rx.functions.Func2;
 import rx.perf.AbstractPerformanceTester;
 import rx.perf.IntegerSumObserver;
-import rx.util.functions.Action0;
-import rx.util.functions.Func2;
 
 public class OperatorZipPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java b/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
index 468f900f88..32ef5c3a7b 100644
--- a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
+++ b/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
@@ -2,7 +2,7 @@
 
 import java.util.Iterator;
 
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public abstract class AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java b/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java
index 6f0cbaef38..7b69baa964 100644
--- a/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java
+++ b/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java
@@ -20,7 +20,7 @@
 
 import rx.Observable;
 import rx.Subscriber;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class PerformanceTest {
 
diff --git a/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java b/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java
index 604c13d406..8cbf000aa5 100644
--- a/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java
+++ b/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java
@@ -18,7 +18,7 @@
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class TestChainPerformance {
 
diff --git a/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java b/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java
index c412130e07..e5f5e5a8b3 100644
--- a/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java
+++ b/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java
@@ -20,7 +20,7 @@
 import rx.Observable;
 import rx.Scheduler;
 import rx.Subscriber;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class SchedulerPerformanceTests {
 
diff --git a/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
index 9b252ba179..7453fb941d 100644
--- a/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
@@ -21,7 +21,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Used for manual testing of memory leaks with recursive schedulers.
diff --git a/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java b/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java
index f6836f975f..4b5f3af5b1 100644
--- a/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java
+++ b/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java
@@ -16,7 +16,7 @@
 package rx.subjects;
 
 import rx.Subscriber;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class SubjectPerformanceTests {
 
diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
index 487f34b558..17931430d4 100644
--- a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
+++ b/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -1,7 +1,7 @@
 package rx.subscriptions;
 
+import rx.functions.Action0;
 import rx.perf.AbstractPerformanceTester;
-import rx.util.functions.Action0;
 
 public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/test/java/rx/CombineLatestTests.java b/rxjava-core/src/test/java/rx/CombineLatestTests.java
index e796f91163..dfc2ec1245 100644
--- a/rxjava-core/src/test/java/rx/CombineLatestTests.java
+++ b/rxjava-core/src/test/java/rx/CombineLatestTests.java
@@ -24,8 +24,8 @@
 import rx.CovarianceTest.Movie;
 import rx.CovarianceTest.Rating;
 import rx.CovarianceTest.Result;
-import rx.util.functions.Action1;
-import rx.util.functions.Func2;
+import rx.functions.Action1;
+import rx.functions.Func2;
 
 public class CombineLatestTests {
     /**
diff --git a/rxjava-core/src/test/java/rx/CovarianceTest.java b/rxjava-core/src/test/java/rx/CovarianceTest.java
index f4f20ea249..adf3a8c9b8 100644
--- a/rxjava-core/src/test/java/rx/CovarianceTest.java
+++ b/rxjava-core/src/test/java/rx/CovarianceTest.java
@@ -19,7 +19,7 @@
 
 import org.junit.Test;
 
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 /**
  * Test super/extends of generics.
diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java
index b3528b9d5c..ad92262695 100644
--- a/rxjava-core/src/test/java/rx/EventStream.java
+++ b/rxjava-core/src/test/java/rx/EventStream.java
@@ -21,8 +21,8 @@
 
 import rx.Observable.OnSubscribeFunc;
 import rx.Scheduler.Inner;
+import rx.functions.Action1;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
 
 /**
  * Utility for retrieving a mock eventstream for testing.
diff --git a/rxjava-core/src/test/java/rx/GroupByTests.java b/rxjava-core/src/test/java/rx/GroupByTests.java
index a254dd3101..414d1ad559 100644
--- a/rxjava-core/src/test/java/rx/GroupByTests.java
+++ b/rxjava-core/src/test/java/rx/GroupByTests.java
@@ -18,9 +18,9 @@
 import org.junit.Test;
 
 import rx.EventStream.Event;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class GroupByTests {
 
diff --git a/rxjava-core/src/test/java/rx/IntervalDemo.java b/rxjava-core/src/test/java/rx/IntervalDemo.java
index d7cf82e762..569e94a79b 100644
--- a/rxjava-core/src/test/java/rx/IntervalDemo.java
+++ b/rxjava-core/src/test/java/rx/IntervalDemo.java
@@ -22,8 +22,8 @@
 import org.junit.Ignore;
 import org.junit.Test;
 
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 @Ignore
 // since this doesn't do any automatic testing
diff --git a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
index 754bc89ef1..9e6968f652 100644
--- a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
+++ b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
@@ -22,8 +22,8 @@
 
 import org.junit.Test;
 
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 public class ObservableDoOnTest {
 
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index 1ada4f37cd..e4a84c15ac 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -35,14 +35,14 @@
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable.OnSubscribeFunc;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.observables.ConnectableObservable;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Action2;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class ObservableTests {
 
diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
index 1ff4a8c59f..f6380cb92a 100644
--- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
@@ -22,8 +22,8 @@
 
 import org.junit.Test;
 
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class ObservableWindowTests {
 
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 4f26939873..5e79fe0a98 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -21,7 +21,7 @@
 
 import rx.CovarianceTest.HorrorMovie;
 import rx.CovarianceTest.Movie;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 public class ReduceTests {
 
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index a017d40b2d..e88454b672 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -27,10 +27,10 @@
 import org.junit.Test;
 import org.mockito.MockitoAnnotations;
 
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 public class RefCountTests {
 
diff --git a/rxjava-core/src/test/java/rx/ScanTests.java b/rxjava-core/src/test/java/rx/ScanTests.java
index d4901e7593..b94b8b50a3 100644
--- a/rxjava-core/src/test/java/rx/ScanTests.java
+++ b/rxjava-core/src/test/java/rx/ScanTests.java
@@ -21,8 +21,8 @@
 import org.junit.Test;
 
 import rx.EventStream.Event;
-import rx.util.functions.Action1;
-import rx.util.functions.Func2;
+import rx.functions.Action1;
+import rx.functions.Func2;
 
 public class ScanTests {
 
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index 9899a92c39..97928a5092 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -28,10 +28,10 @@
 import rx.CovarianceTest.Rating;
 import rx.CovarianceTest.Result;
 import rx.EventStream.Event;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.observables.GroupedObservable;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class ZipTests {
 
diff --git a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
index aefaf9b8dc..6880553736 100644
--- a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -19,8 +19,8 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Action1;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Action1;
 
 public class ExceptionsTest {
 
diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
index 2490f754ee..50b3d8f161 100644
--- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
@@ -30,10 +30,10 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class BlockingObservableTest {
 
diff --git a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
index d86f48a013..89b835ce00 100644
--- a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
@@ -24,8 +24,8 @@
 import rx.Subscriber;
 import rx.exceptions.CompositeException;
 import rx.exceptions.OnErrorNotImplementedException;
+import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
 
 public class SafeObserverTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
index f73eeb5e95..afa35ca0be 100644
--- a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
@@ -24,7 +24,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 public class OnSubscribeRangeTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
index 2ae2eccd5f..e7940a0583 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
@@ -22,7 +22,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationAllTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
index edd31e2e04..42d48f30df 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
@@ -30,9 +30,9 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.CompositeSubscription;
-import rx.util.functions.Action1;
 
 public class OperationAmbTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
index a22cbb8740..eaeca1cad9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
@@ -22,7 +22,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationAnyTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
index 6587e118e8..88f4477aaa 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
@@ -23,8 +23,8 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func1;
 import rx.operators.OperationReduceTest.CustomException;
-import rx.util.functions.Func1;
 
 public class OperationAverageTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index d6b6d86923..04944498b2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -35,12 +35,12 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperationBufferTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
index be0deed811..8637eb8521 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
@@ -27,8 +27,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action1;
 
 public class OperationCacheTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
index 6160f78df5..c58c05a7e2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
@@ -28,11 +28,11 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.FuncN;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
-import rx.util.functions.FuncN;
 
 public class OperationCombineLatestTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index d89c85a318..1f23264ae8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -28,11 +28,11 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperationDebounceTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
index 3c01c11ae8..a33736acb1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
@@ -21,7 +21,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func0;
+import rx.functions.Func0;
 
 public class OperationDeferTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
index 9b583d96f8..df75fc4d25 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
@@ -32,10 +32,10 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperationDelayTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
index d03781df17..9be2508c40 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
@@ -29,7 +29,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationDistinctTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
index e924370f5c..dcd1176f58 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
@@ -29,7 +29,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationDistinctUntilChangedTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
index ce85adcb57..c8e1e622bf 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class OperationFinallyTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
index b14c285acc..84f1b6aee0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
@@ -26,7 +26,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationFirstOrDefaultTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
index bbb6e5d7cf..5b199e4a6e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
@@ -25,9 +25,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 public class OperationFlatMapTest {
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
index d926a10bf2..af1fc94365 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
@@ -34,10 +34,10 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.observables.GroupedObservable;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 public class OperationGroupByUntilTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
index a347cbf587..5e02219178 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
@@ -28,10 +28,10 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class OperationGroupJoinTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
index fd88df8370..9cfc68e033 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
@@ -25,9 +25,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class OperationJoinTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
index 8906e6cf62..85a0890b15 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
@@ -28,13 +28,13 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Functions;
 import rx.joins.Plan0;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
-import rx.util.functions.Functions;
 
 public class OperationJoinsTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
index 960d4a58e8..6cb6d44ff5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
@@ -24,7 +24,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationLastTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
index a4ee85d550..cad4805c7c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
@@ -29,7 +29,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationMinMaxTest {
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
index 1ce4f16821..58a32364ba 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
@@ -28,8 +28,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func1;
 
 public class OperationOnErrorResumeNextViaFunctionTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
index 8951edc836..1c9be8f069 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
@@ -26,7 +26,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationOnErrorResumeNextViaObservableTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
index 11813fac81..356c680470 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
@@ -28,7 +28,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationOnErrorReturnTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
index e15a1eabfb..f2b4b6ff16 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
@@ -26,7 +26,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationOnExceptionResumeNextViaObservableTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
index 84aa301aa3..8a0b4b6770 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
@@ -24,10 +24,10 @@
 import org.junit.Test;
 
 import rx.Observable;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperationParallelMergeTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
index adbce40da7..9bdac54407 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
@@ -26,9 +26,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
-import rx.util.functions.Functions;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Functions;
 
 public class OperationReduceTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
index e3fd042202..a0214fef82 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
@@ -27,11 +27,11 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
 import rx.operators.OperationReplay.VirtualBoundedList;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func1;
 
 public class OperationReplayTest {
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index 0bb0523e22..f925de54cb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -28,10 +28,10 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 public class OperationSampleTest {
     private TestScheduler scheduler;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
index 23a589c4a2..a3abc4c2b7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 public class OperationSequenceEqualTests {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
index 78cd08b1be..dee0f1eb88 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationSingleTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
index b2800015cf..708ac42d50 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
@@ -24,8 +24,8 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 public class OperationSkipWhileTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index 7253e6196f..5553723e00 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperationSumTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index 44a161a623..b09d06abc2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -28,9 +28,9 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 public class OperationSwitchTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
index 033ea8e7d9..fafb23b4ff 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
@@ -25,11 +25,11 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class OperationTakeWhileTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
index c53b6d17d3..6172b7dfb3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
@@ -28,9 +28,9 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 public class OperationThrottleFirstTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
index 6f9db93250..a3d13b0910 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
@@ -29,9 +29,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 
 public class OperationToMapTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
index c9f6fec60e..be4a59654c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
@@ -34,11 +34,11 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.operators.OperationToMultimap.DefaultMultimapCollectionFactory;
 import rx.operators.OperationToMultimap.DefaultToMultimapFactory;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 public class OperationToMultimapTest {
     @Mock
diff --git a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
index 4a7e8f419d..3d4f628d67 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
@@ -26,10 +26,10 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperationUsingTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index 6d175bfe6a..16ac7579d3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -31,13 +31,13 @@
 import rx.Observer;
 import rx.Scheduler.Inner;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperationWindowTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
index 3f1daa80c1..088b83e499 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
@@ -23,8 +23,8 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func2;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func2;
 
 /**
  * Systematically tests that when zipping an infinite and a finite Observable,
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java
index 5b23d63dc3..95dfee2ddd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java
@@ -25,8 +25,8 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class OperatorDoOnEachTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
index 74b0953627..4950520a94 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class OperatorFilterTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 67617cb827..3d3021190d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -35,12 +35,12 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorGroupByTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index 17296ac0d3..f54570f893 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -29,10 +29,10 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
 
 public class OperatorMapTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index f90f8ad3be..2d150e7af1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -35,9 +35,9 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 public class OperatorMergeTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
index 260ea3ae1b..45bf287dab 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
@@ -34,14 +34,14 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TrampolineScheduler;
 import rx.subscriptions.BooleanSubscription;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorObserveOnBoundedTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 1a463ea71e..569aee115a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -32,11 +32,11 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorObserveOnTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
index c8a114ba82..37c0578e19 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
@@ -23,8 +23,8 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class OperatorParallelTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index ce03525167..ba668c125a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -29,9 +29,9 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Func1;
 
 public class OperatorRepeatTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
index 1975b92b78..535478f080 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
@@ -24,7 +24,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 public class OperatorScanTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
index 8ee419abaf..9b55256055 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
@@ -33,6 +33,9 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observables.GroupedObservable;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
@@ -40,9 +43,6 @@
 import rx.schedulers.Timestamped;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorSubscribeOnBoundedTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 8e2e75b66b..8a58166baa 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -29,10 +29,10 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
-import rx.util.functions.Action1;
 
 public class OperatorSubscribeOnTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 6ad7719be9..7df0ae3b32 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -32,10 +32,10 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 public class OperatorTakeTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 3c0e874174..0d1421115c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -34,11 +34,11 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func0;
-import rx.util.functions.Func1;
 
 public class OperatorTimeoutWithSelectorTest {
     @Test(timeout = 2000)
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java
index 4c324f207d..dae17cf4a1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java
@@ -26,7 +26,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.util.functions.Func2;
+import rx.functions.Func2;
 
 public class OperatorToObservableSortedListTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index 9aa75c39c0..b86a015b2c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -14,11 +14,11 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.observers.TestObserver;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 
 public class OperatorUnsubscribeOnTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
index 99e8296539..543cf531cc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
@@ -27,10 +27,10 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Func2;
+import rx.functions.Func3;
 import rx.operators.OperationReduceTest.CustomException;
 import rx.subjects.PublishSubject;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
 
 public class OperatorZipIterableTest {
     Func2 concat2Strings;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index f20b5caab2..e96c8b84b0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -37,13 +37,13 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.FuncN;
+import rx.functions.Functions;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func2;
-import rx.util.functions.Func3;
-import rx.util.functions.FuncN;
-import rx.util.functions.Functions;
 
 public class OperatorZipTest {
     Func2 concat2Strings;
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 69446ed10b..39cac1740b 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -31,10 +31,10 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * Base tests for schedulers that involve threads (concurrency).
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 5e85b5070f..0947bcd884 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -38,10 +38,10 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action0;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * Base tests for all schedulers including Immediate/Current.
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index e7d3fa37e6..bb217ad2ca 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -25,8 +25,8 @@
 import rx.Observable;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class ExecutorSchedulerTests extends AbstractSchedulerConcurrencyTests {
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index d62a5d8822..9f729ea0d3 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -21,8 +21,8 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class ImmediateSchedulerTest extends AbstractSchedulerTests {
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
index af64b87468..09adaa7e28 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -28,8 +28,8 @@
 
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class TestSchedulerTest {
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index ae927567a5..efea8d874e 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -21,8 +21,8 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class TrampolineSchedulerTest extends AbstractSchedulerTests {
 
diff --git a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
index e49d0b3bd4..90eda0ad16 100644
--- a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 public class AsyncSubjectTest {
 
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index b14b9131e6..9c71d4aa5c 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -29,8 +29,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class PublishSubjectTest {
 
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 4d941946b5..3f032b19d0 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -31,8 +31,8 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
 
 public class ReplaySubjectConcurrencyTest {
 
diff --git a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index 6a9c1b9b80..f7b8e0b7c3 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -23,7 +23,7 @@
 import org.junit.Test;
 
 import rx.Subscription;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class MultipleAssignmentSubscriptionTest {
 
diff --git a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
index c3bd3a99b3..1d0e36d424 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
@@ -23,7 +23,7 @@
 import org.mockito.InOrder;
 
 import rx.Subscription;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class RefCountSubscriptionTest {
     Action0 main;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
index 76db10199f..adf9ee4477 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -21,7 +21,7 @@
 import org.junit.Test;
 
 import rx.Subscription;
-import rx.util.functions.Action0;
+import rx.functions.Action0;
 
 public class SubscriptionsTest {
 
diff --git a/rxjava-core/src/test/java/rx/test/OperatorTester.java b/rxjava-core/src/test/java/rx/test/OperatorTester.java
index 418b67965d..b6239130e9 100644
--- a/rxjava-core/src/test/java/rx/test/OperatorTester.java
+++ b/rxjava-core/src/test/java/rx/test/OperatorTester.java
@@ -19,7 +19,7 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Common utility functions for testing operator implementations.
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java
index ca42cba3d5..571bf7df63 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservable.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java
@@ -17,8 +17,8 @@
 
 import rx.Notification;
 import rx.Observable;
-import rx.util.functions.Func1;
-import rx.util.functions.Func2;
+import rx.functions.Func1;
+import rx.functions.Func2;
 
 public class AssertObservable {
     /**

From 548f7cf47c6889acdd3aaa10dbb09cb329db640c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 13:17:17 -0800
Subject: [PATCH 415/441] Remove rx.util usage from sub-modules

All sub-modules and tests building and passing
---
 .../main/clojure/rx/lang/clojure/interop.clj  | 26 ++++----
 .../lang/clojure/interop/DummyObservable.java |  8 +--
 .../clojure/rx/lang/clojure/interop_test.clj  | 60 +++++++++----------
 .../scala/ImplicitFunctionConversions.scala   |  2 +-
 .../main/scala/rx/lang/scala/Observable.scala | 12 ++--
 .../main/scala/rx/lang/scala/Scheduler.scala  |  2 +-
 .../rx/operators/OperatorSubscribeOnTest.java | 15 +++--
 7 files changed, 62 insertions(+), 63 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
index 415aab8bab..5f8b803980 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/interop.clj
@@ -20,7 +20,7 @@
          ; If they want Func1, give them onSubscribe as well so Observable/create can be
          ; used seemlessly with rx/fn.
          ; TODO remove this when OnSubscriberFunc is removed
-         ~@(if (and (= prefix "rx.util.functions.Func")
+         ~@(if (and (= prefix "rx.functions.Func")
                     (some #{1} arities))
              `(rx.Observable$OnSubscribeFunc
                 (~'onSubscribe [~'this observer#]
@@ -28,7 +28,7 @@
 
          ; OnSubscribe is just an Action1, so add it to the list of implemented interfaces
          ; so an action cab be used with Observable/create
-         ~@(if (and (= prefix "rx.util.functions.Action")
+         ~@(if (and (= prefix "rx.functions.Action")
                     (some #{1} arities))
              `(rx.Observable$OnSubscribe))
 
@@ -41,7 +41,7 @@
              arities) ))))
 
 (defn fn*
-  "Given function f, returns an object that implements rx.util.functions.Func0-9
+  "Given function f, returns an object that implements rx.functions.Func0-9
   by delegating the call() method to the given function.
 
   If the f has the wrong arity, an ArityException will be thrown at runtime.
@@ -55,28 +55,28 @@
     (.reduce my-numbers (rx/fn* +))
 
   See:
-    http://netflix.github.io/RxJava/javadoc/rx/util/functions/Func0.html
+    http://netflix.github.io/RxJava/javadoc/rx/functions/Func0.html
   "
   [f]
-  (reify-callable "rx.util.functions.Func" [0 1 2 3 4 5 6 7 8 9] f))
+  (reify-callable "rx.functions.Func" [0 1 2 3 4 5 6 7 8 9] f))
 
 (defn fnN*
-  "Given function f, returns an object that implements rx.util.functions.FuncN
+  "Given function f, returns an object that implements rx.functions.FuncN
   by delegating to the given function.
 
   Unfortunately, this can't be included in fn* because of ambiguities between
   the single arg call() method and the var args call method.
 
   See:
-    http://netflix.github.io/RxJava/javadoc/rx/util/functions/FuncN.html
+    http://netflix.github.io/RxJava/javadoc/rx/functions/FuncN.html
   "
   [f]
-  (reify rx.util.functions.FuncN
+  (reify rx.functions.FuncN
     (call [this objects]
       (apply f objects))))
 
 (defmacro fn
-  "Like clojure.core/fn, but returns the appropriate rx.util.functions.Func*
+  "Like clojure.core/fn, but returns the appropriate rx.functions.Func*
   interface.
 
   Example:
@@ -100,7 +100,7 @@
              (meta &form)))
 
 (defn action*
-  "Given function f, returns an object that implements rx.util.functions.Action0-3
+  "Given function f, returns an object that implements rx.functions.Action0-3
   by delegating to the given function. Also implements rx.Observable$OnSubscribe which
   is just an Action1.
 
@@ -109,13 +109,13 @@
     (.subscribe my-observable (rx/action* println))
 
   See:
-    http://netflix.github.io/RxJava/javadoc/rx/util/functions/Action0.html
+    http://netflix.github.io/RxJava/javadoc/rx/functions/Action0.html
   "
   [f]
-  (reify-callable "rx.util.functions.Action" [0 1 2 3] f))
+  (reify-callable "rx.functions.Action" [0 1 2 3] f))
 
 (defmacro action
-  "Like clojure.core/fn, but returns the appropriate rx.util.functions.Action*
+  "Like clojure.core/fn, but returns the appropriate rx.functions.Action*
   interface.
 
   Example:
diff --git a/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java b/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
index 223c068743..44a5a0b66d 100644
--- a/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
+++ b/language-adaptors/rxjava-clojure/src/main/java/rx/lang/clojure/interop/DummyObservable.java
@@ -24,19 +24,19 @@ public String call(Object f) {
     }
 
     public String call(rx.functions.Func1 f) {
-        return "rx.util.functions.Func1";
+        return "rx.functions.Func1";
     }
 
     public String call(rx.functions.Func2 f) {
-        return "rx.util.functions.Func2";
+        return "rx.functions.Func2";
     }
 
     public String call(rx.functions.Action1 f) {
-        return "rx.util.functions.Action1";
+        return "rx.functions.Action1";
     }
 
     public String call(rx.functions.Action2 f) {
-        return "rx.util.functions.Action2";
+        return "rx.functions.Action2";
     }
 
 }
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
index cd6441ea10..811ec94728 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/interop_test.clj
@@ -9,16 +9,16 @@
   (testing "implements Func0-9"
     (let [f (rx/fn* vector)]
       (is (instance? rx.Observable$OnSubscribeFunc f))
-      (is (instance? rx.util.functions.Func0 f))
-      (is (instance? rx.util.functions.Func1 f))
-      (is (instance? rx.util.functions.Func2 f))
-      (is (instance? rx.util.functions.Func3 f))
-      (is (instance? rx.util.functions.Func4 f))
-      (is (instance? rx.util.functions.Func5 f))
-      (is (instance? rx.util.functions.Func6 f))
-      (is (instance? rx.util.functions.Func7 f))
-      (is (instance? rx.util.functions.Func8 f))
-      (is (instance? rx.util.functions.Func9 f))
+      (is (instance? rx.functions.Func0 f))
+      (is (instance? rx.functions.Func1 f))
+      (is (instance? rx.functions.Func2 f))
+      (is (instance? rx.functions.Func3 f))
+      (is (instance? rx.functions.Func4 f))
+      (is (instance? rx.functions.Func5 f))
+      (is (instance? rx.functions.Func6 f))
+      (is (instance? rx.functions.Func7 f))
+      (is (instance? rx.functions.Func8 f))
+      (is (instance? rx.functions.Func9 f))
       (is (= []                  (.call f)))
       (is (= [1]                 (.call f 1)))
       (is (= [1 2]               (.call f 1 2)))
@@ -35,12 +35,12 @@
       ; No type hint, picks Object overload
       (is (= "Object"
              (.call dummy (rx/fn* +))))
-      (is (= "rx.util.functions.Func1"
+      (is (= "rx.functions.Func1"
              (.call dummy
-                    ^rx.util.functions.Func1 (rx/fn* +))))
-      (is (= "rx.util.functions.Func2"
+                    ^rx.functions.Func1 (rx/fn* +))))
+      (is (= "rx.functions.Func2"
              (.call dummy
-                    ^rx.util.functions.Func2 (rx/fn* *)))))))
+                    ^rx.functions.Func2 (rx/fn* *)))))))
 
 (deftest test-fn
   (testing "makes appropriate Func*"
@@ -53,12 +53,12 @@
       (is (= "Object"
              (.call dummy
                     (rx/fn [a] a))))
-      (is (= "rx.util.functions.Func1"
+      (is (= "rx.functions.Func1"
              (.call dummy
-                    ^rx.util.functions.Func1 (rx/fn [a] a))))
-      (is (= "rx.util.functions.Func2"
+                    ^rx.functions.Func1 (rx/fn [a] a))))
+      (is (= "rx.functions.Func2"
              (.call dummy
-                    ^rx.util.functions.Func2 (rx/fn [a b] (* a b))))))))
+                    ^rx.functions.Func2 (rx/fn [a b] (* a b))))))))
 
 
 (deftest test-fnN*
@@ -71,10 +71,10 @@
     (let [calls (atom [])
           a (rx/action* #(swap! calls conj (vec %&)))]
       (is (instance? rx.Observable$OnSubscribe a))
-      (is (instance? rx.util.functions.Action0 a))
-      (is (instance? rx.util.functions.Action1 a))
-      (is (instance? rx.util.functions.Action2 a))
-      (is (instance? rx.util.functions.Action3 a))
+      (is (instance? rx.functions.Action0 a))
+      (is (instance? rx.functions.Action1 a))
+      (is (instance? rx.functions.Action2 a))
+      (is (instance? rx.functions.Action3 a))
       (.call a)
       (.call a 1)
       (.call a 1 2)
@@ -86,12 +86,12 @@
       (is (= "Object"
              (.call dummy
                     (rx/action* println))))
-      (is (= "rx.util.functions.Action1"
+      (is (= "rx.functions.Action1"
              (.call dummy
-                    ^rx.util.functions.Action1 (rx/action* println))))
-      (is (= "rx.util.functions.Action2"
+                    ^rx.functions.Action1 (rx/action* println))))
+      (is (= "rx.functions.Action2"
              (.call dummy
-                    ^rx.util.functions.Action2 (rx/action* prn)))))))
+                    ^rx.functions.Action2 (rx/action* prn)))))))
 
 (deftest test-action
   (testing "makes appropriate Action*"
@@ -106,12 +106,12 @@
       (is (= "Object"
              (.call dummy
                     (rx/action [a] a))))
-      (is (= "rx.util.functions.Action1"
+      (is (= "rx.functions.Action1"
              (.call dummy
-                    ^rx.util.functions.Action1 (rx/action [a] a))))
-      (is (= "rx.util.functions.Action2"
+                    ^rx.functions.Action1 (rx/action [a] a))))
+      (is (= "rx.functions.Action2"
              (.call dummy
-                    ^rx.util.functions.Action2 (rx/action [a b] (* a b))))))))
+                    ^rx.functions.Action2 (rx/action [a b] (* a b))))))))
 
 (deftest test-basic-usage
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/ImplicitFunctionConversions.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/ImplicitFunctionConversions.scala
index 77cb577277..3c6aa5c29a 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/ImplicitFunctionConversions.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/ImplicitFunctionConversions.scala
@@ -21,7 +21,7 @@ import java.{ lang => jlang }
 import scala.language.implicitConversions
 import scala.collection.Seq
 
-import rx.util.functions._
+import rx.functions._
 import rx.lang.scala.JavaConversions._
 
 
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
index 018eea37fd..9243ec3e6c 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
@@ -16,7 +16,7 @@
 
 package rx.lang.scala
 
-import rx.util.functions.FuncN
+import rx.functions.FuncN
 import rx.Observable.OnSubscribeFunc
 import rx.lang.scala.observables.ConnectableObservable
 import scala.concurrent.duration
@@ -77,7 +77,7 @@ trait Observable[+T]
 {
   import scala.collection.Seq
   import scala.concurrent.duration.{Duration, TimeUnit}
-  import rx.util.functions._
+  import rx.functions._
   import rx.lang.scala.observables.BlockingObservable
   import ImplicitFunctionConversions._
   import JavaConversions._
@@ -278,8 +278,8 @@ trait Observable[+T]
    * @return an Observable that emits timestamped items from the source Observable
    */
   def timestamp: Observable[(Long, T)] = {
-    toScalaObservable[rx.util.Timestamped[_ <: T]](asJavaObservable.timestamp())
-      .map((t: rx.util.Timestamped[_ <: T]) => (t.getTimestampMillis, t.getValue))
+    toScalaObservable[rx.schedulers.Timestamped[_ <: T]](asJavaObservable.timestamp())
+      .map((t: rx.schedulers.Timestamped[_ <: T]) => (t.getTimestampMillis, t.getValue))
   }
 
   /**
@@ -293,8 +293,8 @@ trait Observable[+T]
    *         Observable with timestamps provided by the given Scheduler
    */
   def timestamp(scheduler: Scheduler): Observable[(Long, T)] = {
-    toScalaObservable[rx.util.Timestamped[_ <: T]](asJavaObservable.timestamp(scheduler))
-      .map((t: rx.util.Timestamped[_ <: T]) => (t.getTimestampMillis, t.getValue))
+    toScalaObservable[rx.schedulers.Timestamped[_ <: T]](asJavaObservable.timestamp(scheduler))
+      .map((t: rx.schedulers.Timestamped[_ <: T]) => (t.getTimestampMillis, t.getValue))
   }
 
   /**
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
index db82612c6f..1bfbb69c4e 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
@@ -16,7 +16,7 @@
 package rx.lang.scala
 
 import scala.concurrent.duration.Duration
-import rx.util.functions.Action1
+import rx.functions.Action1
 import rx.lang.scala.schedulers._
 import scala.concurrent.duration
 import rx.lang.scala.JavaConversions._
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 8a58166baa..ba9d171ccc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -52,14 +52,14 @@ public void call(
                             final Subscriber subscriber) {
                         scheduled.countDown();
                         try {
-                            latch.await();
+                            try {
+                                latch.await();
+                            } catch (InterruptedException e) {
+                                // this means we were unsubscribed (Scheduler shut down and interrupts)
+                                // ... but we'll pretend we are like many Observables that ignore interrupts
+                            }
 
-                            System.out.println("emit onCompleted");
-                            // this should not run because the await above will be interrupted by the unsubscribe
                             subscriber.onCompleted();
-                        } catch (InterruptedException e) {
-                            e.printStackTrace();
-                            throw new RuntimeException("should not occur since we are not interuppting");
                         } catch (Throwable e) {
                             subscriber.onError(e);
                         } finally {
@@ -75,8 +75,7 @@ public void call(
         latch.countDown();
         doneLatch.await();
         assertEquals(0, observer.getOnErrorEvents().size());
-        // the unsubscribe shuts down the scheduler which causes the latch to be interrupted
-        assertEquals(0, observer.getOnCompletedEvents().size());
+        assertEquals(1, observer.getOnCompletedEvents().size());
     }
 
     public static class SlowScheduler extends Scheduler {

From f4c83f432299ca40369ee03c3b178da38879e5da Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 13:34:13 -0800
Subject: [PATCH 416/441] rx.util.functions deprecated proxies

---
 .../main/java/rx/util/functions/Action.java   |  24 +
 .../main/java/rx/util/functions/Action0.java  |  23 +
 .../main/java/rx/util/functions/Action1.java  |  23 +
 .../main/java/rx/util/functions/Action2.java  |  23 +
 .../main/java/rx/util/functions/Action3.java  |  23 +
 .../main/java/rx/util/functions/Action4.java  |  24 +
 .../main/java/rx/util/functions/Action5.java  |  24 +
 .../main/java/rx/util/functions/Action6.java  |  24 +
 .../main/java/rx/util/functions/Action7.java  |  23 +
 .../main/java/rx/util/functions/Action8.java  |  23 +
 .../main/java/rx/util/functions/Action9.java  |  23 +
 .../main/java/rx/util/functions/ActionN.java  |  23 +
 .../main/java/rx/util/functions/Actions.java  | 465 ++++++++++++++++++
 .../main/java/rx/util/functions/Func0.java    |  23 +
 .../main/java/rx/util/functions/Func1.java    |  23 +
 .../main/java/rx/util/functions/Func2.java    |  23 +
 .../main/java/rx/util/functions/Func3.java    |  23 +
 .../main/java/rx/util/functions/Func4.java    |  23 +
 .../main/java/rx/util/functions/Func5.java    |  23 +
 .../main/java/rx/util/functions/Func6.java    |  23 +
 .../main/java/rx/util/functions/Func7.java    |  23 +
 .../main/java/rx/util/functions/Func8.java    |  23 +
 .../main/java/rx/util/functions/Func9.java    |  23 +
 .../main/java/rx/util/functions/FuncN.java    |  24 +
 .../main/java/rx/util/functions/Function.java |  24 +
 .../java/rx/util/functions/Functions.java     | 365 ++++++++++++++
 .../src/main/java/rx/util/functions/Not.java  |  40 ++
 27 files changed, 1428 insertions(+)
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action0.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action1.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action2.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action3.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action4.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action5.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action6.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action7.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action8.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Action9.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/ActionN.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Actions.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func0.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func1.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func2.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func3.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func4.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func5.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func6.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func7.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func8.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Func9.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/FuncN.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Function.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Functions.java
 create mode 100644 rxjava-core/src/main/java/rx/util/functions/Not.java

diff --git a/rxjava-core/src/main/java/rx/util/functions/Action.java b/rxjava-core/src/main/java/rx/util/functions/Action.java
new file mode 100644
index 0000000000..cddf3c196c
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action extends rx.functions.Action {
+
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action0.java b/rxjava-core/src/main/java/rx/util/functions/Action0.java
new file mode 100644
index 0000000000..0611d35984
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action0.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action0 extends rx.functions.Action0 {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action1.java b/rxjava-core/src/main/java/rx/util/functions/Action1.java
new file mode 100644
index 0000000000..1ec94d630d
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action1.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action1 extends rx.functions.Action1, Action {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action2.java b/rxjava-core/src/main/java/rx/util/functions/Action2.java
new file mode 100644
index 0000000000..bde1b863ec
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action2.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action2 extends rx.functions.Action2, Action {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action3.java b/rxjava-core/src/main/java/rx/util/functions/Action3.java
new file mode 100644
index 0000000000..91ce6ed3a4
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action3.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action3 extends rx.functions.Action3, Action {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action4.java b/rxjava-core/src/main/java/rx/util/functions/Action4.java
new file mode 100644
index 0000000000..d9c1030ee5
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action4.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action4 extends rx.functions.Action4, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action5.java b/rxjava-core/src/main/java/rx/util/functions/Action5.java
new file mode 100644
index 0000000000..53d5884fc3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action5.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action5 extends rx.functions.Action5, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action6.java b/rxjava-core/src/main/java/rx/util/functions/Action6.java
new file mode 100644
index 0000000000..08d95fb504
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action6.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action6 extends rx.functions.Action6, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action7.java b/rxjava-core/src/main/java/rx/util/functions/Action7.java
new file mode 100644
index 0000000000..095bc5945b
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action7.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action7 extends rx.functions.Action7, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action8.java b/rxjava-core/src/main/java/rx/util/functions/Action8.java
new file mode 100644
index 0000000000..8512994fb2
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action8.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action8 extends rx.functions.Action8, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action9.java b/rxjava-core/src/main/java/rx/util/functions/Action9.java
new file mode 100644
index 0000000000..eebf66a6fb
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Action9.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Action9 extends rx.functions.Action9, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/ActionN.java b/rxjava-core/src/main/java/rx/util/functions/ActionN.java
new file mode 100644
index 0000000000..e0a586aec1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/ActionN.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface ActionN extends rx.functions.ActionN, Action {
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Actions.java b/rxjava-core/src/main/java/rx/util/functions/Actions.java
new file mode 100644
index 0000000000..4cf9342097
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Actions.java
@@ -0,0 +1,465 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+import rx.Observer;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public final class Actions {
+    private Actions() {
+        throw new IllegalStateException("No instances!");
+    }
+
+    public static final EmptyAction empty() {
+        return EMPTY_ACTION;
+    }
+
+    private static final EmptyAction EMPTY_ACTION = new EmptyAction();
+
+    private static final class EmptyAction implements Action0, Action1, Action2, Action3, Action4, Action5, Action6, Action7, Action8, Action9, ActionN {
+        @Override
+        public void call() {
+        }
+
+        @Override
+        public void call(Object t1) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8) {
+        }
+
+        @Override
+        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8, Object t9) {
+        }
+
+        @Override
+        public void call(Object... args) {
+        }
+    }
+    
+    /**
+     * Extracts a method reference to the observer's onNext method
+     * in the form of an Action1.
+     * 
    Java 8: observer::onNext
    
+     * 
+     * @param observer
+     *            the observer to use
+     * @return an action which calls the observer's onNext method.
+     */
+    public static  Action1 onNextFrom(final Observer observer) {
+        return new Action1() {
+            @Override
+            public void call(T t1) {
+                observer.onNext(t1);
+            }
+        };
+    }
+
+    /**
+     * Extracts a method reference to the observer's onError method
+     * in the form of an Action1.
+     * 
    Java 8: observer::onError
    
+     * 
+     * @param observer
+     *            the observer to use
+     * @return an action which calls the observer's onError method.
+     */
+    public static  Action1 onErrorFrom(final Observer observer) {
+        return new Action1() {
+            @Override
+            public void call(Throwable t1) {
+                observer.onError(t1);
+            }
+        };
+    }
+
+    /**
+     * Extracts a method reference to the observer's onCompleted method
+     * in the form of an Action0.
+     * 
    Java 8: observer::onCompleted
    
+     * 
+     * @param observer
+     *            the observer to use
+     * @return an action which calls the observer's onCompleted method.
+     */
+    public static  Action0 onCompletedFrom(final Observer observer) {
+        return new Action0() {
+            @Override
+            public void call() {
+                observer.onCompleted();
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static Func0 toFunc(final Action0 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func1 toFunc(final Action1 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func2 toFunc(final Action2 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func3 toFunc(final Action3 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func4 toFunc(final Action4 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func5 toFunc(
+            final Action5 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func6 toFunc(
+            final Action6 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func7 toFunc(
+            final Action7 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func8 toFunc(
+            final Action8 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static  Func9 toFunc(
+            final Action9 action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @return {@link Func0}
+     */
+    public static FuncN toFunc(
+            final ActionN action) {
+        return toFunc(action, (Void) null);
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns the given result.
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func0 toFunc(final Action0 action, final R result) {
+        return new Func0() {
+            @Override
+            public R call() {
+                action.call();
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func1 toFunc(final Action1 action, final R result) {
+        return new Func1() {
+            @Override
+            public R call(T1 t1) {
+                action.call(t1);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func2 toFunc(final Action2 action, final R result) {
+        return new Func2() {
+            @Override
+            public R call(T1 t1, T2 t2) {
+                action.call(t1, t2);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func3 toFunc(final Action3 action, final R result) {
+        return new Func3() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3) {
+                action.call(t1, t2, t3);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func4 toFunc(final Action4 action, final R result) {
+        return new Func4() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
+                action.call(t1, t2, t3, t4);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func5 toFunc(
+            final Action5 action, final R result) {
+        return new Func5() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
+                action.call(t1, t2, t3, t4, t5);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func6 toFunc(
+            final Action6 action, final R result) {
+        return new Func6() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
+                action.call(t1, t2, t3, t4, t5, t6);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func7 toFunc(
+            final Action7 action, final R result) {
+        return new Func7() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
+                action.call(t1, t2, t3, t4, t5, t6, t7);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func8 toFunc(
+            final Action8 action, final R result) {
+        return new Func8() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
+                action.call(t1, t2, t3, t4, t5, t6, t7, t8);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  Func9 toFunc(
+            final Action9 action, final R result) {
+        return new Func9() {
+            @Override
+            public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
+                action.call(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Convert an action to a function which calls
+     * the action returns Void (null).
+     * 
+     * @param action
+     * @param result
+     * @return {@link Func0}
+     */
+    public static  FuncN toFunc(
+            final ActionN action, final R result) {
+        return new FuncN() {
+            @Override
+            public R call(Object... args) {
+                action.call(args);
+                return result;
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func0.java b/rxjava-core/src/main/java/rx/util/functions/Func0.java
new file mode 100644
index 0000000000..ef238acdc1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func0.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func0 extends rx.functions.Func0, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func1.java b/rxjava-core/src/main/java/rx/util/functions/Func1.java
new file mode 100644
index 0000000000..6f58689895
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func1.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func1 extends rx.functions.Func1, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func2.java b/rxjava-core/src/main/java/rx/util/functions/Func2.java
new file mode 100644
index 0000000000..ea2b5a2ee2
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func2.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func2 extends rx.functions.Func2, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func3.java b/rxjava-core/src/main/java/rx/util/functions/Func3.java
new file mode 100644
index 0000000000..198cc8dfea
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func3.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func3 extends rx.functions.Func3, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func4.java b/rxjava-core/src/main/java/rx/util/functions/Func4.java
new file mode 100644
index 0000000000..a3f3bc6c45
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func4.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func4 extends rx.functions.Func4, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func5.java b/rxjava-core/src/main/java/rx/util/functions/Func5.java
new file mode 100644
index 0000000000..8dd96ba9e3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func5.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func5 extends rx.functions.Func5, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func6.java b/rxjava-core/src/main/java/rx/util/functions/Func6.java
new file mode 100644
index 0000000000..b049b12772
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func6.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func6 extends rx.functions.Func6, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func7.java b/rxjava-core/src/main/java/rx/util/functions/Func7.java
new file mode 100644
index 0000000000..c807188c5f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func7.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func7 extends rx.functions.Func7, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func8.java b/rxjava-core/src/main/java/rx/util/functions/Func8.java
new file mode 100644
index 0000000000..bc3ca7afc6
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func8.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func8 extends rx.functions.Func8, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func9.java b/rxjava-core/src/main/java/rx/util/functions/Func9.java
new file mode 100644
index 0000000000..51f18c43b1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Func9.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Func9 extends rx.functions.Func9, Function {
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/FuncN.java b/rxjava-core/src/main/java/rx/util/functions/FuncN.java
new file mode 100644
index 0000000000..144bdeb13b
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/FuncN.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface FuncN extends Function {
+    public R call(Object... args);
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Function.java b/rxjava-core/src/main/java/rx/util/functions/Function.java
new file mode 100644
index 0000000000..facacfd2ee
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Function.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public interface Function {
+
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Functions.java b/rxjava-core/src/main/java/rx/util/functions/Functions.java
new file mode 100644
index 0000000000..a0a8f01130
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Functions.java
@@ -0,0 +1,365 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public class Functions {
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func0 f) {
+        return new FuncN() {
+
+            @Override
+            public R call(Object... args) {
+                if (args.length != 0) {
+                    throw new RuntimeException("Func0 expecting 0 arguments.");
+                }
+                return f.call();
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func1 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 1) {
+                    throw new RuntimeException("Func1 expecting 1 argument.");
+                }
+                return f.call((T0) args[0]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func2 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 2) {
+                    throw new RuntimeException("Func2 expecting 2 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func3 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 3) {
+                    throw new RuntimeException("Func3 expecting 3 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func4 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 4) {
+                    throw new RuntimeException("Func4 expecting 4 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func5 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 5) {
+                    throw new RuntimeException("Func5 expecting 5 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func6 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 6) {
+                    throw new RuntimeException("Func6 expecting 6 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func7 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 7) {
+                    throw new RuntimeException("Func7 expecting 7 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func8 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 8) {
+                    throw new RuntimeException("Func8 expecting 8 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6], (T7) args[7]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromFunc(final Func9 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public R call(Object... args) {
+                if (args.length != 9) {
+                    throw new RuntimeException("Func9 expecting 9 arguments.");
+                }
+                return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6], (T7) args[7], (T8) args[8]);
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static FuncN fromAction(final Action0 f) {
+        return new FuncN() {
+
+            @Override
+            public Void call(Object... args) {
+                if (args.length != 0) {
+                    throw new RuntimeException("Action0 expecting 0 arguments.");
+                }
+                f.call();
+                return null;
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromAction(final Action1 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void call(Object... args) {
+                if (args.length != 1) {
+                    throw new RuntimeException("Action1 expecting 1 argument.");
+                }
+                f.call((T0) args[0]);
+                return null;
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromAction(final Action2 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void call(Object... args) {
+                if (args.length != 2) {
+                    throw new RuntimeException("Action3 expecting 2 arguments.");
+                }
+                f.call((T0) args[0], (T1) args[1]);
+                return null;
+            }
+
+        };
+    }
+
+    /**
+     * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
+     * 
+     * @param f
+     * @return {@link FuncN}
+     */
+    public static  FuncN fromAction(final Action3 f) {
+        return new FuncN() {
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void call(Object... args) {
+                if (args.length != 3) {
+                    throw new RuntimeException("Action3 expecting 3 arguments.");
+                }
+                f.call((T0) args[0], (T1) args[1], (T2) args[2]);
+                return null;
+            }
+
+        };
+    }
+
+    /**
+     * Constructs a predicate that returns true for each input that the source
+     * predicate returns false for and vice versa.
+     * 
+     * @param predicate
+     *            The source predicate to negate.
+     */
+    public static  Func1 not(Func1 predicate) {
+        return new Not(predicate);
+    }
+
+    public static  Func1 alwaysTrue() {
+        return AlwaysTrue.INSTANCE;
+    }
+
+    public static  Func1 alwaysFalse() {
+        return AlwaysFalse.INSTANCE;
+    }
+
+    public static  Func1 identity() {
+        return new Func1() {
+            @Override
+            public T call(T o) {
+                return o;
+            }
+        };
+    }
+
+    private enum AlwaysTrue implements Func1 {
+        INSTANCE;
+
+        @Override
+        public Boolean call(Object o) {
+            return true;
+        }
+    }
+
+    private enum AlwaysFalse implements Func1 {
+        INSTANCE;
+
+        @Override
+        public Boolean call(Object o) {
+            return false;
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/util/functions/Not.java b/rxjava-core/src/main/java/rx/util/functions/Not.java
new file mode 100644
index 0000000000..5c2726c3fe
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/util/functions/Not.java
@@ -0,0 +1,40 @@
+/**
+ * Copyright 2014 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.util.functions;
+
+/**
+ * @deprecated
+ */
+@Deprecated
+public class Not implements Func1 {
+    private final Func1 predicate;
+
+    /**
+     * Constructs a predicate that returns true for each input that the source
+     * predicate returns false for and vice versa.
+     * 
+     * @param predicate
+     *            The source predicate to negate.
+     */
+    public Not(Func1 predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Boolean call(T param) {
+        return !predicate.call(param);
+    }
+}
\ No newline at end of file

From 1ef689dd9200a915ba47ea5875bacf8a1ca8485d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Sat, 15 Feb 2014 10:27:07 -0800
Subject: [PATCH 417/441] Lift Performance

Using `f.lift()` directly instead of `subscribe` improves ops/second on the included test from 5,907,721 ops/sec to 10,145,486 ops/sec
---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../composition/RangeMapTakeOnNextPerf.java   | 71 +++++++++++++++++++
 2 files changed, 73 insertions(+), 2 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 08a826b0d6..1a4f37920b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -261,11 +261,11 @@ public static interface OnSubscribeFunc extends Function {
      * @return an Observable that emits values that are the result of applying the bind function to the values
      *         of the current Observable
      */
-    public  Observable lift(final Operator bind) {
+    public  Observable lift(final Operator lift) {
         return new Observable(new OnSubscribe() {
             @Override
             public void call(Subscriber o) {
-                subscribe(hook.onLift(bind).call(o));
+                f.call(hook.onLift(lift).call(o));
             }
         });
     }
diff --git a/rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java b/rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java
new file mode 100644
index 0000000000..8bb8942357
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java
@@ -0,0 +1,71 @@
+package rx.composition;
+
+import rx.Observable;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+import rx.util.functions.Action0;
+import rx.util.functions.Func1;
+
+public class RangeMapTakeOnNextPerf extends AbstractPerformanceTester {
+
+    final static int NUM = 10;
+    final static long REPS = REPETITIONS / NUM;
+
+    RangeMapTakeOnNextPerf() {
+        super(REPS);
+    }
+
+    public static void main(String args[]) {
+
+        final RangeMapTakeOnNextPerf spt = new RangeMapTakeOnNextPerf();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.test();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 
+     * With 'lift' calling the `f` function directly:
+     * 
+     * Run: 10 - 11,152,996 ops/sec
+     * Run: 11 - 9,791,825 ops/sec
+     * Run: 12 - 10,080,035 ops/sec
+     * Run: 13 - 10,189,525 ops/sec
+     * Run: 14 - 10,145,486 ops/sec
+     * 
+     * With `lift` calling `subscribe`:
+     * 
+     * Run: 10 - 5,592,153 ops/sec
+     * Run: 11 - 5,881,799 ops/sec
+     * Run: 12 - 5,853,430 ops/sec
+     * Run: 13 - 5,902,769 ops/sec
+     * Run: 14 - 5,907,721 ops/sec
+     */
+    public long test() {
+
+        Observable s = Observable.range(0, 100).map(new Func1() {
+
+            @Override
+            public Integer call(Integer l) {
+                return l + 1;
+            }
+
+        }).take(NUM);
+        IntegerSumObserver o = new IntegerSumObserver();
+
+        for (long l = 0; l < REPS; l++) {
+            s.subscribe(o);
+        }
+        return o.sum;
+    }
+
+}
\ No newline at end of file

From 68983965c9f742f88bd626ad30dc71f7684c648c Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 13:38:34 -0800
Subject: [PATCH 418/441] Fix DebugHookTest as per direction from @abersnaze

---
 .../rxjava-debug/src/test/java/rx/debug/DebugHookTest.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
index 5a113ffc73..92c6cdd0dd 100644
--- a/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
+++ b/rxjava-contrib/rxjava-debug/src/test/java/rx/debug/DebugHookTest.java
@@ -63,7 +63,7 @@ public void onError(Throwable e) {
             public void onNext(Integer t) {
             }
         });
-        verify(events, times(6)).call(subscribe());
+        verify(events, atLeast(3)).call(subscribe());
         verify(events, times(4)).call(onNext(1));
         // one less because it originates from the inner observable sent to merge
         verify(events, times(3)).call(onNext(2));

From 37523c0415b72bfd896d7cf312187222a77d7d8b Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 12:50:19 -0800
Subject: [PATCH 419/441] Refactor OnErrorResumeNextViaFunction to Operator

---
 rxjava-core/src/main/java/rx/Observable.java   |  4 ++--
 ... OperatorOnErrorResumeNextViaFunction.java} | 18 +++++++++++++++---
 ...ratorOnErrorResumeNextViaFunctionTest.java} |  4 ++--
 3 files changed, 19 insertions(+), 7 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationOnErrorResumeNextViaFunction.java => OperatorOnErrorResumeNextViaFunction.java} (91%)
 rename rxjava-core/src/test/java/rx/operators/{OperationOnErrorResumeNextViaFunctionTest.java => OperatorOnErrorResumeNextViaFunctionTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 1a4f37920b..4bc18832e9 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -79,7 +79,7 @@
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMinMax;
 import rx.operators.OperationMulticast;
-import rx.operators.OperationOnErrorResumeNextViaFunction;
+import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
@@ -5209,7 +5209,7 @@ public final Boolean call(T t) {
      * @see RxJava Wiki: onErrorResumeNext()
      */
     public final Observable onErrorResumeNext(final Func1> resumeFunction) {
-        return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
+        return create(OperatorOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
similarity index 91%
rename from rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
rename to rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
index a3f3c694bb..1a7825b75d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -20,7 +20,9 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.functions.Action0;
@@ -46,10 +48,18 @@
  * You can use this to prevent errors from propagating or to supply fallback data should errors be
  * encountered.
  */
-public final class OperationOnErrorResumeNextViaFunction {
+public final class OperatorOnErrorResumeNextViaFunction implements Operator {
 
-    public static  OnSubscribeFunc onErrorResumeNextViaFunction(Observable originalSequence, Func1> resumeFunction) {
-        return new OnErrorResumeNextViaFunction(originalSequence, resumeFunction);
+    private final Func1> resumeFunction;
+    
+    OperatorOnErrorResumeNextViaFunction(Func1> f) {
+        this.resumeFunction = f;
+    }
+    
+    @Override
+    public Subscriber call(Subscriber t1) {
+        // TODO Auto-generated method stub
+        return null;
     }
 
     private static class OnErrorResumeNextViaFunction implements OnSubscribeFunc {
@@ -116,4 +126,6 @@ public void call() {
             });
         }
     }
+
+
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index 58a32364ba..faafc3ae15 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -18,7 +18,7 @@
 import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationOnErrorResumeNextViaFunction.*;
+import static rx.operators.OperatorOnErrorResumeNextViaFunction.*;
 
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -31,7 +31,7 @@
 import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
 
-public class OperationOnErrorResumeNextViaFunctionTest {
+public class OperatorOnErrorResumeNextViaFunctionTest {
 
     @Test
     public void testResumeNextWithSynchronousExecution() {

From ffbf2ff185be16a4e8bdb108ff829dd6708d50ac Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 15:23:59 -0800
Subject: [PATCH 420/441] onErrorFlatMap + OnErrorThrowable

---
 rxjava-core/src/main/java/rx/Observable.java  | 18 +++-
 .../java/rx/exceptions/OnErrorThrowable.java  | 52 ++++++++++
 .../main/java/rx/operators/OperatorCast.java  |  8 +-
 .../java/rx/operators/OperatorDoOnEach.java   |  3 +-
 .../java/rx/operators/OperatorFilter.java     | 12 +--
 .../java/rx/operators/OperatorGroupBy.java    |  3 +-
 .../main/java/rx/operators/OperatorMap.java   |  3 +-
 .../rx/operators/OperatorOnErrorFlatMap.java  | 82 ++++++++++++++++
 .../OperatorOnErrorResumeNextViaFunction.java | 98 +++++--------------
 .../main/java/rx/operators/OperatorScan.java  |  4 +-
 .../main/java/rx/operators/OperatorZip.java   | 10 +-
 .../operators/OperatorOnErrorFlatMapTest.java | 89 +++++++++++++++++
 ...ratorOnErrorResumeNextViaFunctionTest.java |  9 +-
 13 files changed, 292 insertions(+), 99 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4bc18832e9..8079d53532 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -25,6 +25,7 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.exceptions.Exceptions;
+import rx.exceptions.OnErrorThrowable;
 import rx.exceptions.OnErrorNotImplementedException;
 import rx.functions.Action0;
 import rx.functions.Action1;
@@ -79,7 +80,6 @@
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMinMax;
 import rx.operators.OperationMulticast;
-import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
@@ -87,8 +87,6 @@
 import rx.operators.OperationReplay;
 import rx.operators.OperationRetry;
 import rx.operators.OperationSample;
-import rx.operators.OperatorObserveOnBounded;
-import rx.operators.OperatorScan;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSingle;
 import rx.operators.OperationSkip;
@@ -117,8 +115,11 @@
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
 import rx.operators.OperatorObserveOn;
+import rx.operators.OperatorOnErrorResumeNextViaFunction;
+import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorRepeat;
+import rx.operators.OperatorScan;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimeout;
@@ -5209,7 +5210,7 @@ public final Boolean call(T t) {
      * @see RxJava Wiki: onErrorResumeNext()
      */
     public final Observable onErrorResumeNext(final Func1> resumeFunction) {
-        return create(OperatorOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
+        return lift(new OperatorOnErrorResumeNextViaFunction(resumeFunction));
     }
 
     /**
@@ -5267,6 +5268,15 @@ public final Observable onErrorReturn(Func1 resumeFun
         return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
     }
 
+    /**
+     * Allows inserting onNext events into a stream when onError events are received
+     * and continuing the original sequence instead of terminating. Thus it allows a sequence
+     * with multiple onError events.
+     */
+    public final Observable onErrorFlatMap(final Func1> resumeFunction) {
+        return lift(new OperatorOnErrorFlatMap(resumeFunction));
+    }
+
     /**
      * Instruct an Observable to pass control to another Observable rather than invoking
      * {@link Observer#onError onError} if it encounters an {@link java.lang.Exception}.
diff --git a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
new file mode 100644
index 0000000000..16a040c71c
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright 2014 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.exceptions;
+
+public class OnErrorThrowable extends RuntimeException {
+
+    private static final long serialVersionUID = -569558213262703934L;
+
+    private final boolean hasValue;
+    private final Object value;
+
+    public OnErrorThrowable(Throwable exception) {
+        super(exception);
+        hasValue = false;
+        this.value = null;
+    }
+
+    public OnErrorThrowable(Throwable exception, Object value) {
+        super(exception);
+        hasValue = true;
+        this.value = value;
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public boolean isValueNull() {
+        return hasValue;
+    }
+
+    public static OnErrorThrowable from(Throwable t) {
+        if (t instanceof OnErrorThrowable) {
+            return (OnErrorThrowable) t;
+        } else {
+            return new OnErrorThrowable(t);
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCast.java b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
index 3322c8355c..2955d1f647 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
@@ -17,7 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
-
+import rx.exceptions.OnErrorThrowable;
 
 /**
  * Converts the elements of an observable sequence to the specified type.
@@ -46,7 +46,11 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(T t) {
-                o.onNext(castClass.cast(t));
+                try {
+                    o.onNext(castClass.cast(t));
+                } catch (Throwable e) {
+                    onError(new OnErrorThrowable(e, t));
+                }
             }
         };
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
index d321852c72..7a2a813a87 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
@@ -18,6 +18,7 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 
 /**
  * Converts the elements of an observable sequence to the specified type.
@@ -59,7 +60,7 @@ public void onNext(T value) {
                 try {
                     doOnEachObserver.onNext(value);
                 } catch (Throwable e) {
-                    onError(e);
+                    onError(new OnErrorThrowable(e, value));
                     return;
                 }
                 observer.onNext(value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index 6b46148147..8a9e07312e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -17,8 +17,8 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func1;
-import rx.observables.GroupedObservable;
 
 /**
  * Filters an Observable by discarding any items it emits that do not meet some test.
@@ -48,13 +48,13 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(T value) {
+            public void onNext(T t) {
                 try {
-                    if (predicate.call(value)) {
-                        child.onNext(value);
+                    if (predicate.call(t)) {
+                        child.onNext(t);
                     }
-                } catch (Throwable ex) {
-                    child.onError(ex);
+                } catch (Throwable e) {
+                    child.onError(new OnErrorThrowable(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 6279cd92d5..10288ce871 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -23,6 +23,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.observables.GroupedObservable;
@@ -130,7 +131,7 @@ public void onNext(T t) {
                     // we have the correct group so send value to it
                     gps.onNext(t);
                 } catch (Throwable e) {
-                    onError(e);
+                    onError(new OnErrorThrowable(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index efb09bae01..cb94ee4886 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -17,6 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func1;
 
 /**
@@ -52,7 +53,7 @@ public void onNext(T t) {
                 try {
                     o.onNext(transformer.call(t));
                 } catch (Throwable e) {
-                    onError(e);
+                    onError(new OnErrorThrowable(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
new file mode 100644
index 0000000000..92806aad7e
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
@@ -0,0 +1,82 @@
+/**
+ * Copyright 2014 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 rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
+import rx.functions.Func1;
+
+/**
+ * Allows inserting onNext events into a stream when onError events are received
+ * and continuing the original sequence instead of terminating. Thus it allows a sequence
+ * with multiple onError events.
+ */
+public final class OperatorOnErrorFlatMap implements Operator {
+
+    private final Func1> resumeFunction;
+
+    public OperatorOnErrorFlatMap(Func1> f) {
+        this.resumeFunction = f;
+    }
+
+    @Override
+    public Subscriber call(final Subscriber child) {
+        return new Subscriber(child) {
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    Observable resume = resumeFunction.call(OnErrorThrowable.from(e));
+                    resume.subscribe(new Subscriber() {
+
+                        @Override
+                        public void onCompleted() {
+                            // ignore as we will continue the parent Observable
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            // if the splice also fails we shut it all down
+                            child.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(T t) {
+                            child.onNext(t);
+                        }
+
+                    });
+                } catch (Throwable e2) {
+                    child.onError(e2);
+                }
+            }
+
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
index 1a7825b75d..5b3adc2360 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -15,19 +15,10 @@
  */
 package rx.operators;
 
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
-
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observable.Operator;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
-import rx.exceptions.CompositeException;
-import rx.functions.Action0;
 import rx.functions.Func1;
-import rx.subscriptions.Subscriptions;
 
 /**
  * Instruct an Observable to pass control to another Observable (the return value of a function)
@@ -51,81 +42,36 @@
 public final class OperatorOnErrorResumeNextViaFunction implements Operator {
 
     private final Func1> resumeFunction;
-    
-    OperatorOnErrorResumeNextViaFunction(Func1> f) {
+
+    public OperatorOnErrorResumeNextViaFunction(Func1> f) {
         this.resumeFunction = f;
     }
-    
-    @Override
-    public Subscriber call(Subscriber t1) {
-        // TODO Auto-generated method stub
-        return null;
-    }
-
-    private static class OnErrorResumeNextViaFunction implements OnSubscribeFunc {
-
-        private final Func1> resumeFunction;
-        private final Observable originalSequence;
 
-        public OnErrorResumeNextViaFunction(Observable originalSequence, Func1> resumeFunction) {
-            this.resumeFunction = resumeFunction;
-            this.originalSequence = originalSequence;
-        }
-
-        public Subscription onSubscribe(final Observer observer) {
-            // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
-            final AtomicReference subscriptionRef = new AtomicReference(new SafeObservableSubscription());
+    @Override
+    public Subscriber call(final Subscriber child) {
+        return new Subscriber(child) {
 
-            // subscribe to the original Observable and remember the subscription
-            subscriptionRef.get().wrap(new SafeObservableSubscription(originalSequence.subscribe(new Observer() {
-                public void onNext(T value) {
-                    // forward the successful calls
-                    observer.onNext(value);
-                }
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
 
-                /**
-                 * Instead of passing the onError forward, we intercept and "resume" with the resumeSequence.
-                 */
-                public void onError(Throwable ex) {
-                    /* remember what the current subscription is so we can determine if someone unsubscribes concurrently */
-                    SafeObservableSubscription currentSubscription = subscriptionRef.get();
-                    // check that we have not been unsubscribed before we can process the error
-                    if (currentSubscription != null) {
-                        try {
-                            Observable resumeSequence = resumeFunction.call(ex);
-                            /* error occurred, so switch subscription to the 'resumeSequence' */
-                            SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.subscribe(observer));
-                            /* we changed the sequence, so also change the subscription to the one of the 'resumeSequence' instead */
-                            if (!subscriptionRef.compareAndSet(currentSubscription, innerSubscription)) {
-                                // we failed to set which means 'subscriptionRef' was set to NULL via the unsubscribe below
-                                // so we want to immediately unsubscribe from the resumeSequence we just subscribed to
-                                innerSubscription.unsubscribe();
-                            }
-                        } catch (Throwable e) {
-                            // the resume function failed so we need to call onError
-                            // I am using CompositeException so that both exceptions can be seen
-                            observer.onError(new CompositeException("OnErrorResume function failed", Arrays.asList(ex, e)));
-                        }
-                    }
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    Observable resume = resumeFunction.call(e);
+                    resume.subscribe(child);
+                } catch (Throwable e2) {
+                    child.onError(e2);
                 }
+            }
 
-                public void onCompleted() {
-                    // forward the successful calls
-                    observer.onCompleted();
-                }
-            })));
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
 
-            return Subscriptions.create(new Action0() {
-                public void call() {
-                    // this will get either the original, or the resumeSequence one and unsubscribe on it
-                    Subscription s = subscriptionRef.getAndSet(null);
-                    if (s != null) {
-                        s.unsubscribe();
-                    }
-                }
-            });
-        }
+        };
     }
 
-
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
index 1428f25225..5498d7e76d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -17,6 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func2;
 
 /**
@@ -96,8 +97,7 @@ public void onNext(T value) {
                     try {
                         this.value = accumulator.call(this.value, value);
                     } catch (Throwable e) {
-                        observer.onError(e);
-                        observer.unsubscribe();
+                        observer.onError(new OnErrorThrowable(e, value));
                     }
                 }
                 observer.onNext(this.value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index ad560d713b..32bacd34ce 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -22,6 +22,7 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func2;
 import rx.functions.Func3;
 import rx.functions.Func4;
@@ -189,8 +190,13 @@ void tick() {
                         }
                     }
                     if (allHaveValues) {
-                        // all have something so emit
-                        observer.onNext(zipFunction.call(vs));
+                        try {
+                            // all have something so emit
+                            observer.onNext(zipFunction.call(vs));
+                        } catch (Throwable e) {
+                            observer.onError(new OnErrorThrowable(e, vs));
+                            return;
+                        }
                         // now remove them
                         for (int i = 0; i < observers.length; i++) {
                             ((InnerObserver) observers[i]).items.poll();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java
new file mode 100644
index 0000000000..5fc9b62866
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright 2014 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 static org.junit.Assert.*;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.exceptions.OnErrorThrowable;
+import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+
+public class OperatorOnErrorFlatMapTest {
+
+    @Test
+    public void ignoreErrorsAndContinueEmitting() {
+        TestSubscriber ts = new TestSubscriber();
+        Observable.from(1, 2, 3, 4, 5, 6).map(new Func1() {
+
+            @Override
+            public String call(Integer v) {
+                if (v < 2 || v > 5) {
+                    return "Value=" + v;
+                }
+                throw new RuntimeException("error in map function: " + v);
+            }
+
+        }).onErrorFlatMap(new Func1>() {
+
+            @Override
+            public Observable call(OnErrorThrowable t) {
+                return Observable.empty();
+            }
+
+        }).subscribe(ts);
+
+        ts.assertTerminalEvent();
+        System.out.println(ts.getOnErrorEvents());
+        assertEquals(0, ts.getOnErrorEvents().size());
+        System.out.println(ts.getOnNextEvents());
+        ts.assertReceivedOnNext(Arrays.asList("Value=1", "Value=6"));
+    }
+
+    @Test
+    public void spliceAndContinueEmitting() {
+        TestSubscriber ts = new TestSubscriber();
+        Observable.from(1, 2, 3, 4, 5, 6).map(new Func1() {
+
+            @Override
+            public String call(Integer v) {
+                if (v < 2 || v > 5) {
+                    return "Value=" + v;
+                }
+                throw new RuntimeException("error in map function: " + v);
+            }
+
+        }).onErrorFlatMap(new Func1>() {
+
+            @Override
+            public Observable call(OnErrorThrowable t) {
+                return Observable.from("Error=" + t.getValue());
+            }
+
+        }).subscribe(ts);
+
+        ts.assertTerminalEvent();
+        System.out.println(ts.getOnErrorEvents());
+        assertEquals(0, ts.getOnErrorEvents().size());
+        System.out.println(ts.getOnNextEvents());
+        ts.assertReceivedOnNext(Arrays.asList("Value=1", "Error=2", "Error=3", "Error=4", "Error=5", "Value=6"));
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index faafc3ae15..b071d863d6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -18,8 +18,8 @@
 import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperatorOnErrorResumeNextViaFunction.*;
 
+import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
@@ -29,6 +29,7 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.functions.Func1;
+import rx.observers.TestSubscriber;
 import rx.subscriptions.Subscriptions;
 
 public class OperatorOnErrorResumeNextViaFunctionTest {
@@ -55,7 +56,7 @@ public Observable call(Throwable t1) {
             }
 
         };
-        Observable observable = Observable.create(onErrorResumeNextViaFunction(w, resume));
+        Observable observable = w.onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer observer = mock(Observer.class);
@@ -85,7 +86,7 @@ public Observable call(Throwable t1) {
             }
 
         };
-        Observable observable = Observable.create(onErrorResumeNextViaFunction(Observable.create(w), resume));
+        Observable observable = Observable.create(w).onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer observer = mock(Observer.class);
@@ -122,7 +123,7 @@ public Observable call(Throwable t1) {
             }
 
         };
-        Observable observable = Observable.create(onErrorResumeNextViaFunction(Observable.create(w), resume));
+        Observable observable = Observable.create(w).onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer observer = mock(Observer.class);

From 36dceba61a98e5b63026576b9fa84d860e91dd2e Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 16:00:17 -0800
Subject: [PATCH 421/441] Change Parallel to use Long instead of Int

---
 .../java/rx/operators/OperatorParallel.java   | 20 +++---
 .../OperatorParallelPerformance.java          | 66 +++++++++++++++++++
 2 files changed, 77 insertions(+), 9 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
index d5ef638fcd..0e9893a54b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
@@ -29,33 +29,35 @@ public final class OperatorParallel implements Operator {
 
     private final Scheduler scheduler;
     private final Func1, Observable> f;
+    private final int degreeOfParallelism;
 
     public OperatorParallel(Func1, Observable> f, Scheduler scheduler) {
         this.scheduler = scheduler;
         this.f = f;
+        this.degreeOfParallelism = scheduler.degreeOfParallelism();
     }
 
     @Override
     public Subscriber call(Subscriber op) {
 
-        Func1>, Subscriber> groupBy =
-                new OperatorGroupBy(new Func1() {
+        Func1>, Subscriber> groupBy =
+                new OperatorGroupBy(new Func1() {
 
-                    int i = 0;
+                    long i = 0;
 
                     @Override
-                    public Integer call(T t) {
-                        return i++ % scheduler.degreeOfParallelism();
+                    public Long call(T t) {
+                        return i++ % degreeOfParallelism;
                     }
 
                 });
 
-        Func1>, Subscriber>> map =
-                new OperatorMap, Observable>(
-                        new Func1, Observable>() {
+        Func1>, Subscriber>> map =
+                new OperatorMap, Observable>(
+                        new Func1, Observable>() {
 
                             @Override
-                            public Observable call(GroupedObservable g) {
+                            public Observable call(GroupedObservable g) {
                                 // Must use observeOn not subscribeOn because we have a single source behind groupBy.
                                 // The origin is already subscribed to, we are moving each group on to a new thread
                                 // but the origin itself can only be on a single thread.
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java
new file mode 100644
index 0000000000..818407d7e4
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java
@@ -0,0 +1,66 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+
+public class OperatorParallelPerformance extends AbstractPerformanceTester {
+
+    private final static int REPS = 10000000;
+
+    OperatorParallelPerformance() {
+        super(REPS);
+    }
+
+    public static void main(String args[]) {
+
+        final OperatorParallelPerformance spt = new OperatorParallelPerformance();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.parallelSum();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 
+     * Run: 10 - 11,220,888 ops/sec
+     * Run: 11 - 12,372,424 ops/sec
+     * Run: 12 - 11,028,921 ops/sec
+     * Run: 13 - 11,813,711 ops/sec
+     * Run: 14 - 12,098,364 ops/sec
+     * 
+     */
+    public long parallelSum() {
+
+        Observable s = Observable.range(1, REPS).parallel(new Func1, Observable>() {
+
+            @Override
+            public Observable call(Observable l) {
+                return l.map(new Func1() {
+
+                    @Override
+                    public Integer call(Integer i) {
+                        return i + 1;
+                    }
+
+                });
+            }
+
+        });
+        IntegerSumObserver o = new IntegerSumObserver();
+
+        s.subscribe(o);
+        return o.sum;
+    }
+
+}
\ No newline at end of file

From f74bb41657f57974ce372b76f9fe44895e8aed61 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 16:41:29 -0800
Subject: [PATCH 422/441] Synchronized Operator Check for isTerminated

As per https://github.com/Netflix/RxJava/issues/872 make Synchronized reject events after terminal state.
This class should not unsubscribe though. That is only for SafeSubscriber at the end.
---
 .../java/rx/observers/SynchronizedObserver.java | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
index eedecd1368..25ea8c3403 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
@@ -41,7 +41,8 @@ public final class SynchronizedObserver implements Observer {
      */
 
     private final Observer observer;
-    private volatile Object lock;
+    private final Object lock;
+    private boolean isTerminated = false;
 
     public SynchronizedObserver(Observer subscriber) {
         this.observer = subscriber;
@@ -55,19 +56,27 @@ public SynchronizedObserver(Observer subscriber, Object lock) {
 
     public void onNext(T arg) {
         synchronized (lock) {
-            observer.onNext(arg);
+            if (!isTerminated) {
+                observer.onNext(arg);
+            }
         }
     }
 
     public void onError(Throwable e) {
         synchronized (lock) {
-            observer.onError(e);
+            if (!isTerminated) {
+                isTerminated = true;
+                observer.onError(e);
+            }
         }
     }
 
     public void onCompleted() {
         synchronized (lock) {
-            observer.onCompleted();
+            if (!isTerminated) {
+                isTerminated = true;
+                observer.onCompleted();
+            }
         }
     }
 }
\ No newline at end of file

From 945e0ce84ea8c6319f5f2eebd1774d977f087049 Mon Sep 17 00:00:00 2001
From: George Campbell 
Date: Mon, 17 Feb 2014 21:57:24 -0800
Subject: [PATCH 423/441] removing java 7 dep

---
 .../main/java/rx/observables/StringObservable.java | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
index dfbea5a720..16f410bf6d 100644
--- a/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
+++ b/rxjava-contrib/rxjava-string/src/main/java/rx/observables/StringObservable.java
@@ -27,7 +27,6 @@
 import java.nio.charset.CoderResult;
 import java.nio.charset.CodingErrorAction;
 import java.util.Arrays;
-import java.util.Objects;
 import java.util.regex.Pattern;
 
 import rx.Observable;
@@ -461,14 +460,23 @@ public String getText() {
 
         @Override
         public int hashCode() {
-            return Objects.hash(number, text);
+            int result = 31 + number;
+            result = 31 * result + (text == null ? 0 : text.hashCode());
+            return result;
         }
 
         @Override
         public boolean equals(Object obj) {
             if (!(obj instanceof Line))
                 return false;
-            return Objects.equals(number, ((Line) obj).number) && Objects.equals(text, ((Line) obj).text);
+            Line other = (Line) obj;
+            if (number != other.number)
+                return false;
+            if (other.text == text)
+                return true;
+            if (text == null)
+                return false;
+            return text.equals(other.text);
         }
 
         @Override

From e2b67b8c4c37c072dcd224448a9f1b5849d19884 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Tue, 18 Feb 2014 11:56:18 +0800
Subject: [PATCH 424/441] Rewrite OperationObserveFromAndroidComponent to
 OperatorObserveFromAndroidComponent

---
 .../observables/AndroidObservable.java        |  8 +-
 .../subscriptions/AndroidSubscriptions.java   | 55 +++++++++++++
 .../OperatorCompoundButtonInput.java          | 16 +---
 .../rx/operators/OperatorEditTextInput.java   | 16 +---
 ... OperatorObserveFromAndroidComponent.java} | 30 +++----
 .../java/rx/operators/OperatorViewClick.java  | 16 +---
 ...ratorObserveFromAndroidComponentTest.java} | 81 +++++++------------
 .../HandlerThreadSchedulerTest.java           |  8 +-
 8 files changed, 112 insertions(+), 118 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-android/src/main/java/rx/android/subscriptions/AndroidSubscriptions.java
 rename rxjava-contrib/rxjava-android/src/main/java/rx/operators/{OperationObserveFromAndroidComponent.java => OperatorObserveFromAndroidComponent.java} (85%)
 rename rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/{OperationObserveFromAndroidComponentTest.java => OperatorObserveFromAndroidComponentTest.java} (69%)

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
index a6af28b555..d55617ddea 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java
@@ -16,7 +16,7 @@
 package rx.android.observables;
 
 import rx.Observable;
-import rx.operators.OperationObserveFromAndroidComponent;
+import rx.operators.OperatorObserveFromAndroidComponent;
 import android.app.Activity;
 import android.app.Fragment;
 import android.os.Build;
@@ -59,7 +59,7 @@ private AndroidObservable() {}
      * @return a new observable sequence that will emit notifications on the main UI thread
      */
     public static  Observable fromActivity(Activity activity, Observable sourceObservable) {
-        return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, activity);
+        return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, activity);
     }
 
     /**
@@ -88,9 +88,9 @@ public static  Observable fromActivity(Activity activity, Observable so
      */
     public static  Observable fromFragment(Object fragment, Observable sourceObservable) {
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
-            return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (android.support.v4.app.Fragment) fragment);
+            return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (android.support.v4.app.Fragment) fragment);
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
-            return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (Fragment) fragment);
+            return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (Fragment) fragment);
         } else {
             throw new IllegalArgumentException("Target fragment is neither a native nor support library Fragment");
         }
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/subscriptions/AndroidSubscriptions.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/subscriptions/AndroidSubscriptions.java
new file mode 100644
index 0000000000..8e2f54ab3e
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/subscriptions/AndroidSubscriptions.java
@@ -0,0 +1,55 @@
+/**
+ * Copyright 2014 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.android.subscriptions;
+
+import rx.Scheduler.Inner;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.subscriptions.Subscriptions;
+import android.os.Looper;
+
+public final class AndroidSubscriptions {
+
+    private AndroidSubscriptions() {
+        // no instance
+    }
+
+    /**
+     * Create an Subscription that always runs unsubscribe in the UI thread.
+     * 
+     * @param unsubscribe
+     * @return an Subscription that always runs unsubscribe in the UI thread.
+     */
+    public static Subscription unsubscribeInUiThread(final Action0 unsubscribe) {
+        return Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                if (Looper.getMainLooper() == Looper.myLooper()) {
+                    unsubscribe.call();
+                } else {
+                    AndroidSchedulers.mainThread().schedule(new Action1() {
+                        @Override
+                        public void call(Inner inner) {
+                            unsubscribe.call();
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
index 63687f440e..9a61093699 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
@@ -23,12 +23,9 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.Scheduler.Inner;
 import rx.android.observables.ViewObservable;
-import rx.android.schedulers.AndroidSchedulers;
+import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
 import android.view.View;
 import android.widget.CompoundButton;
 
@@ -53,17 +50,10 @@ public void onCheckedChanged(final CompoundButton button, final boolean checked)
             }
         };
 
-        final Subscription subscription = Subscriptions.create(new Action0() {
+        final Subscription subscription = AndroidSubscriptions.unsubscribeInUiThread(new Action0() {
             @Override
             public void call() {
-                AndroidSchedulers.mainThread().schedule(new Action1() {
-
-                    @Override
-                    public void call(Inner t1) {
-                        composite.removeOnCheckedChangeListener(listener);
-                    }
-
-                });
+                composite.removeOnCheckedChangeListener(listener);
             }
         });
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
index 1aa08f73a9..1dcbac0014 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorEditTextInput.java
@@ -18,12 +18,9 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.Scheduler.Inner;
 import rx.android.observables.ViewObservable;
-import rx.android.schedulers.AndroidSchedulers;
+import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
 import android.text.Editable;
 import android.text.TextWatcher;
 import android.widget.EditText;
@@ -47,17 +44,10 @@ public void afterTextChanged(final Editable editable) {
             }
         };
         
-        final Subscription subscription = Subscriptions.create(new Action0() {
+        final Subscription subscription = AndroidSubscriptions.unsubscribeInUiThread(new Action0() {
             @Override
             public void call() {
-                AndroidSchedulers.mainThread().schedule(new Action1() {
-
-                    @Override
-                    public void call(Inner t1) {
-                        input.removeTextChangedListener(watcher);
-                    }
-
-                });
+                input.removeTextChangedListener(watcher);
             }
         });
 
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
similarity index 85%
rename from rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
rename to rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
index dba31a954b..3e656ccfbb 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperationObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
@@ -17,17 +17,15 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Subscription;
-import rx.Scheduler.Inner;
+import rx.Subscriber;
 import rx.android.schedulers.AndroidSchedulers;
+import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
 import android.app.Activity;
 import android.os.Looper;
 import android.util.Log;
 
-public class OperationObserveFromAndroidComponent {
+public class OperatorObserveFromAndroidComponent {
 
     public static  Observable observeFromAndroidComponent(Observable source, android.app.Fragment fragment) {
         return Observable.create(new OnSubscribeFragment(source, fragment));
@@ -41,7 +39,7 @@ public static  Observable observeFromAndroidComponent(Observable source
         return Observable.create(new OnSubscribeBase(source, activity));
     }
 
-    private static class OnSubscribeBase implements Observable.OnSubscribeFunc {
+    private static class OnSubscribeBase implements Observable.OnSubscribe {
 
         private static final String LOG_TAG = "AndroidObserver";
 
@@ -67,10 +65,10 @@ protected boolean isComponentValid(AndroidComponent component) {
         }
 
         @Override
-        public Subscription onSubscribe(Observer observer) {
+        public void call(Subscriber subscriber) {
             assertUiThread();
-            observerRef = observer;
-            final Subscription sourceSub = source.observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer() {
+            observerRef = subscriber;
+            source.observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber(subscriber) {
                 @Override
                 public void onCompleted() {
                     if (componentRef != null && isComponentValid(componentRef)) {
@@ -98,21 +96,13 @@ public void onNext(T args) {
                     }
                 }
             });
-            return Subscriptions.create(new Action0() {
+            subscriber.add(AndroidSubscriptions.unsubscribeInUiThread(new Action0() {
                 @Override
                 public void call() {
                     log("unsubscribing from source sequence");
-                    AndroidSchedulers.mainThread().schedule(new Action1() {
-
-                        @Override
-                        public void call(Inner t1) {
-                            releaseReferences();
-                            sourceSub.unsubscribe();
-                        }
-
-                    });
+                    releaseReferences();
                 }
-            });
+            }));
         }
 
         private void releaseReferences() {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
index 086fb53a40..1fb2bb8b91 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorViewClick.java
@@ -21,14 +21,11 @@
 import java.util.WeakHashMap;
 
 import rx.Observable;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.android.observables.ViewObservable;
-import rx.android.schedulers.AndroidSchedulers;
+import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
 import android.view.View;
 
 public final class OperatorViewClick implements Observable.OnSubscribe {
@@ -52,17 +49,10 @@ public void onClick(final View clicked) {
             }
         };
 
-        final Subscription subscription = Subscriptions.create(new Action0() {
+        final Subscription subscription = AndroidSubscriptions.unsubscribeInUiThread(new Action0() {
             @Override
             public void call() {
-                AndroidSchedulers.mainThread().schedule(new Action1() {
-
-                    @Override
-                    public void call(Inner t1) {
-                        composite.removeOnClickListener(listener);
-                    }
-
-                });
+                composite.removeOnClickListener(listener);
             }
         });
 
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
similarity index 69%
rename from rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
rename to rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
index e19dda4482..70a9c881fb 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperationObserveFromAndroidComponentTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
@@ -15,13 +15,19 @@
  */
 package rx.android.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -38,23 +44,19 @@
 import org.robolectric.annotation.Config;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
-import rx.Subscription;
 import rx.android.schedulers.AndroidSchedulers;
 import rx.functions.Action1;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
-import rx.operators.OperationObserveFromAndroidComponent;
+import rx.operators.OperatorObserveFromAndroidComponent;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.BooleanSubscription;
-import android.app.Activity;
 import android.app.Fragment;
 
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
-public class OperationObserveFromAndroidComponentTest {
+public class OperatorObserveFromAndroidComponentTest {
 
     @Mock
     private Observer mockObserver;
@@ -62,9 +64,6 @@ public class OperationObserveFromAndroidComponentTest {
     @Mock
     private Fragment mockFragment;
 
-    @Mock
-    private Activity mockActivity;
-
     @Before
     public void setupMocks() {
         MockitoAnnotations.initMocks(this);
@@ -77,7 +76,7 @@ public void itThrowsIfObserverSubscribesFromBackgroundThread() throws Exception
         final Future future = Executors.newSingleThreadExecutor().submit(new Callable() {
             @Override
             public Object call() throws Exception {
-                OperationObserveFromAndroidComponent.observeFromAndroidComponent(
+                OperatorObserveFromAndroidComponent.observeFromAndroidComponent(
                         testObservable, mockFragment).subscribe(mockObserver);
                 return null;
             }
@@ -109,7 +108,7 @@ public void call(Integer t1) {
                 });
 
         final AtomicReference currentThreadName = new AtomicReference();
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(testObservable, mockFragment).subscribe(new Action1() {
+        OperatorObserveFromAndroidComponent.observeFromAndroidComponent(testObservable, mockFragment).subscribe(new Action1() {
 
             @Override
             public void call(Integer i) {
@@ -129,8 +128,8 @@ public void call(Integer i) {
 
     @Test
     public void itForwardsOnNextOnCompletedSequenceToTargetObserver() {
-        Observable source = Observable.from(1, 2, 3);
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
+        Observable source = Observable.from(Arrays.asList(1, 2, 3));
+        OperatorObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
         verify(mockObserver, times(3)).onNext(anyInt());
         verify(mockObserver).onCompleted();
         verify(mockObserver, never()).onError(any(Exception.class));
@@ -140,7 +139,7 @@ public void itForwardsOnNextOnCompletedSequenceToTargetObserver() {
     public void itForwardsOnErrorToTargetObserver() {
         final Exception exception = new Exception();
         Observable source = Observable.error(exception);
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
+        OperatorObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
         verify(mockObserver).onError(exception);
         verify(mockObserver, never()).onNext(anyInt());
         verify(mockObserver, never()).onCompleted();
@@ -150,8 +149,8 @@ public void itForwardsOnErrorToTargetObserver() {
     public void itDropsOnNextOnCompletedSequenceIfTargetComponentIsGone() throws Throwable {
         PublishSubject source = PublishSubject.create();
 
-        final Observable.OnSubscribeFunc operator = newOnSubscribeFragmentInstance(source, mockFragment);
-        operator.onSubscribe(new TestSubscriber(mockObserver));
+        final Observable.OnSubscribe operator = newOnSubscribeFragmentInstance(source, mockFragment);
+        operator.call(new TestSubscriber(mockObserver));
 
         source.onNext(1);
         releaseComponentRef(operator);
@@ -168,8 +167,8 @@ public void itDropsOnNextOnCompletedSequenceIfTargetComponentIsGone() throws Thr
     public void itDropsOnErrorIfTargetComponentIsGone() throws Throwable {
         PublishSubject source = PublishSubject.create();
 
-        final Observable.OnSubscribeFunc operator = newOnSubscribeFragmentInstance(source, mockFragment);
-        operator.onSubscribe(new TestSubscriber(mockObserver));
+        final Observable.OnSubscribe operator = newOnSubscribeFragmentInstance(source, mockFragment);
+        operator.call(new TestSubscriber(mockObserver));
 
         source.onNext(1);
         releaseComponentRef(operator);
@@ -180,11 +179,12 @@ public void itDropsOnErrorIfTargetComponentIsGone() throws Throwable {
         verifyNoMoreInteractions(mockObserver);
     }
 
-    private Observable.OnSubscribeFunc newOnSubscribeFragmentInstance(Observable source, Fragment fragment) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
-        final Class[] klasses = OperationObserveFromAndroidComponent.class.getDeclaredClasses();
-        Class onSubscribeFragmentClass = null;
-        for (Class klass : klasses) {
-            if ("rx.operators.OperationObserveFromAndroidComponent$OnSubscribeFragment".equals(klass.getName())) {
+    @SuppressWarnings("unchecked")
+    private Observable.OnSubscribe newOnSubscribeFragmentInstance(Observable source, Fragment fragment) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
+        final Class[] klasses = OperatorObserveFromAndroidComponent.class.getDeclaredClasses();
+        Class onSubscribeFragmentClass = null;
+        for (Class klass : klasses) {
+            if ("rx.operators.OperatorObserveFromAndroidComponent$OnSubscribeFragment".equals(klass.getName())) {
                 onSubscribeFragmentClass = klass;
                 break;
             }
@@ -192,10 +192,10 @@ private Observable.OnSubscribeFunc newOnSubscribeFragmentInstance(Obser
         Constructor constructor = onSubscribeFragmentClass.getDeclaredConstructor(Observable.class, Fragment.class);
         constructor.setAccessible(true);
         Object object = constructor.newInstance(source, fragment);
-        return (Observable.OnSubscribeFunc) object;
+        return (Observable.OnSubscribe) object;
     }
 
-    private void releaseComponentRef(Observable.OnSubscribeFunc operator) throws NoSuchFieldException, IllegalAccessException {
+    private void releaseComponentRef(Observable.OnSubscribe operator) throws NoSuchFieldException, IllegalAccessException {
         final Field componentRef = operator.getClass().getSuperclass().getDeclaredField("componentRef");
         componentRef.setAccessible(true);
         componentRef.set(operator, null);
@@ -204,7 +204,7 @@ private void releaseComponentRef(Observable.OnSubscribeFunc operator) t
     @Test
     public void itDoesNotForwardOnNextOnCompletedSequenceIfFragmentIsDetached() {
         PublishSubject source = PublishSubject.create();
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
+        OperatorObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
 
         source.onNext(1);
 
@@ -220,7 +220,7 @@ public void itDoesNotForwardOnNextOnCompletedSequenceIfFragmentIsDetached() {
     @Test
     public void itDoesNotForwardOnErrorIfFragmentIsDetached() {
         PublishSubject source = PublishSubject.create();
-        OperationObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
+        OperatorObserveFromAndroidComponent.observeFromAndroidComponent(source, mockFragment).subscribe(new TestObserver(mockObserver));
 
         source.onNext(1);
 
@@ -231,25 +231,4 @@ public void itDoesNotForwardOnErrorIfFragmentIsDetached() {
         verify(mockObserver, never()).onError(any(Exception.class));
     }
 
-    @Test
-    public void itUnsubscribesFromTheSourceSequence() {
-        final BooleanSubscription s = new BooleanSubscription();
-        Observable testObservable = Observable.create(new OnSubscribeFunc() {
-
-            @Override
-            public Subscription onSubscribe(Observer o) {
-                o.onNext(1);
-                o.onCompleted();
-                return s;
-            }
-
-        });
-
-        Subscription sub = OperationObserveFromAndroidComponent.observeFromAndroidComponent(
-                testObservable, mockActivity).subscribe(new TestObserver(mockObserver));
-        sub.unsubscribe();
-
-        assertTrue(s.isUnsubscribed());
-    }
-
 }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
index 73cde11caa..d68bd258f0 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/schedulers/HandlerThreadSchedulerTest.java
@@ -15,8 +15,10 @@
  */
 package rx.android.schedulers;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 import java.util.concurrent.TimeUnit;
 
@@ -28,9 +30,7 @@
 
 import rx.Scheduler;
 import rx.Scheduler.Inner;
-import rx.Subscription;
 import rx.functions.Action1;
-import rx.functions.Func2;
 import android.os.Handler;
 
 @RunWith(RobolectricTestRunner.class)

From 7babfaf1dcf8f20d02e0404c2f13f47c46a55391 Mon Sep 17 00:00:00 2001
From: zsxwing 
Date: Mon, 17 Feb 2014 11:56:31 +0800
Subject: [PATCH 425/441] Make Subscriptions of SwingObservable thread-safe

---
 .../java/rx/observables/SwingObservable.java  |  12 ++
 .../rx/subscriptions/SwingSubscriptions.java  |  55 ++++++
 .../swing/sources/AbstractButtonSource.java   |  97 +++++-----
 .../swing/sources/ComponentEventSource.java   |  27 ++-
 .../java/rx/swing/sources/KeyEventSource.java | 180 ++++++++++--------
 .../rx/swing/sources/MouseEventSource.java    | 132 +++++++------
 .../rx/swing/sources/SwingTestHelper.java     |  68 +++++++
 7 files changed, 375 insertions(+), 196 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
 create mode 100644 rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java

diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
index 3f859d5365..ab22538e2e 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/observables/SwingObservable.java
@@ -25,6 +25,7 @@
 import java.util.Set;
 
 import javax.swing.AbstractButton;
+import javax.swing.SwingUtilities;
 
 import rx.Observable;
 import rx.functions.Func1;
@@ -140,4 +141,15 @@ public static Observable fromComponentEvents(Component component
     public static Observable fromResizing(Component component) {
         return ComponentEventSource.fromResizing(component);
     }
+
+    /**
+     * Check if the current thead is the event dispatch thread.
+     * 
+     * @throws IllegalStateException if the current thread is not the event dispatch thread.
+     */
+    public static void assertEventDispatchThread() {
+        if (!SwingUtilities.isEventDispatchThread()) {
+            throw new IllegalStateException("Need to run in the event dispatch thread, but was " + Thread.currentThread());
+        }
+    }
 }
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
new file mode 100644
index 0000000000..ce3c18e2d8
--- /dev/null
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
@@ -0,0 +1,55 @@
+/**
+ * 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.subscriptions;
+
+import javax.swing.SwingUtilities;
+
+import rx.Scheduler.Inner;
+import rx.Subscription;
+import rx.schedulers.SwingScheduler;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+public final class SwingSubscriptions {
+
+    private SwingSubscriptions() {
+        // no instance
+    }
+
+    /**
+     * Create an Subscription that always runs unsubscribe in the event dispatch thread.
+     * 
+     * @param unsubscribe
+     * @return an Subscription that always runs unsubscribe in the event dispatch thread.
+     */
+    public static Subscription unsubscribeInEventDispatchThread(final Action0 unsubscribe) {
+        return Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                if (SwingUtilities.isEventDispatchThread()) {
+                    unsubscribe.call();
+                } else {
+                    SwingScheduler.getInstance().schedule(new Action1() {
+                        @Override
+                        public void call(Inner inner) {
+                            unsubscribe.call();
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
index 2c4d7bdad0..037c9fa9e0 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
@@ -15,7 +15,10 @@
  */
 package rx.swing.sources;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -26,12 +29,13 @@
 import org.mockito.Matchers;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
+import rx.observables.SwingObservable;
+import rx.subscriptions.SwingSubscriptions;
 
 public enum AbstractButtonSource { ; // no instances
 
@@ -39,63 +43,70 @@ public enum AbstractButtonSource { ; // no instances
      * @see rx.observables.SwingObservable#fromButtonAction
      */
     public static Observable fromActionOf(final AbstractButton button) {
-        return Observable.create(new OnSubscribeFunc() {
+        return Observable.create(new OnSubscribe() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
+            public void call(final Subscriber subscriber) {
+                SwingObservable.assertEventDispatchThread();
                 final ActionListener listener = new ActionListener() {
                     @Override
                     public void actionPerformed(ActionEvent e) {
-                        observer.onNext(e);
+                        subscriber.onNext(e);
                     }
                 };
                 button.addActionListener(listener);
-                
-                return Subscriptions.create(new Action0() {
+                subscriber.add(SwingSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
                     @Override
                     public void call() {
                         button.removeActionListener(listener);
                     }
-                });
+                }));
             }
         });
     }
 
     public static class UnitTest {
         @Test
-        public void testObservingActionEvents() {
-            @SuppressWarnings("unchecked")
-            Action1 action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1 error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            final ActionEvent event = new ActionEvent(this, 1, "command");
-            
-            @SuppressWarnings("serial")
-            class TestButton extends AbstractButton {
-                void testAction() {
-                    fireActionPerformed(event);
+        public void testObservingActionEvents() throws Throwable {
+            SwingTestHelper.create().runInEventDispatchThread(new Action0() {
+
+                @Override
+                public void call() {
+                    @SuppressWarnings("unchecked")
+                    Action1 action = mock(Action1.class);
+                    @SuppressWarnings("unchecked")
+                    Action1 error = mock(Action1.class);
+                    Action0 complete = mock(Action0.class);
+
+                    final ActionEvent event = new ActionEvent(this, 1, "command");
+
+                    @SuppressWarnings("serial")
+                    class TestButton extends AbstractButton {
+                        void testAction() {
+                            fireActionPerformed(event);
+                        }
+                    }
+
+                    TestButton button = new TestButton();
+                    Subscription sub = fromActionOf(button).subscribe(action, error, complete);
+
+                    verify(action, never()).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+
+                    button.testAction();
+                    verify(action, times(1)).call(Matchers. any());
+
+                    button.testAction();
+                    verify(action, times(2)).call(Matchers. any());
+
+                    sub.unsubscribe();
+                    button.testAction();
+                    verify(action, times(2)).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
                 }
-            }
-            
-            TestButton button = new TestButton();
-            Subscription sub = fromActionOf(button).subscribe(action, error, complete);
-            
-            verify(action, never()).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
-            
-            button.testAction();
-            verify(action, times(1)).call(Matchers.any());
-            
-            button.testAction();
-            verify(action, times(2)).call(Matchers.any());
-            
-            sub.unsubscribe();
-            button.testAction();
-            verify(action, times(2)).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
+
+            }).awaitTerminal();
         }
     }
 }
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
index 7ba8bf43c5..eb2b3a5c41 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
@@ -15,7 +15,7 @@
  */
 package rx.swing.sources;
 
-import static rx.swing.sources.ComponentEventSource.Predicate.*;
+import static rx.swing.sources.ComponentEventSource.Predicate.RESIZED;
 
 import java.awt.Component;
 import java.awt.Dimension;
@@ -23,13 +23,12 @@
 import java.awt.event.ComponentListener;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.observables.SwingObservable;
-import rx.subscriptions.Subscriptions;
+import rx.subscriptions.SwingSubscriptions;
 
 public enum ComponentEventSource { ; // no instances
 
@@ -37,38 +36,38 @@ public enum ComponentEventSource { ; // no instances
      * @see rx.observables.SwingObservable#fromComponentEvents
      */
     public static Observable fromComponentEventsOf(final Component component) {
-        return Observable.create(new OnSubscribeFunc() {
+        return Observable.create(new OnSubscribe() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
+            public void call(final Subscriber subscriber) {
+                SwingObservable.assertEventDispatchThread();
                 final ComponentListener listener = new ComponentListener() {
                     @Override
                     public void componentHidden(ComponentEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void componentMoved(ComponentEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void componentResized(ComponentEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void componentShown(ComponentEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
                 };
                 component.addComponentListener(listener);
-                
-                return Subscriptions.create(new Action0() {
+                subscriber.add(SwingSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
                     @Override
                     public void call() {
                         component.removeComponentListener(listener);
                     }
-                });
+                }));
             }
         });
     }
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
index a56c244ad5..1b5107de08 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
@@ -15,8 +15,12 @@
  */
 package rx.swing.sources;
 
-import static java.util.Arrays.*;
-import static org.mockito.Mockito.*;
+import static java.util.Arrays.asList;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.awt.Component;
 import java.awt.event.KeyEvent;
@@ -32,14 +36,15 @@
 import org.mockito.Matchers;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
-import rx.subscriptions.Subscriptions;
+import rx.observables.SwingObservable;
+import rx.subscriptions.SwingSubscriptions;
 
 public enum KeyEventSource { ; // no instances
 
@@ -47,33 +52,34 @@ public enum KeyEventSource { ; // no instances
      * @see rx.observables.SwingObservable#fromKeyEvents(Component)
      */
     public static Observable fromKeyEventsOf(final Component component) {
-        return Observable.create(new OnSubscribeFunc() {
+        return Observable.create(new OnSubscribe() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
+            public void call(final Subscriber subscriber) {
+                SwingObservable.assertEventDispatchThread();
                 final KeyListener listener = new KeyListener() {
                     @Override
                     public void keyPressed(KeyEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
-  
+
                     @Override
                     public void keyReleased(KeyEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
-  
+
                     @Override
                     public void keyTyped(KeyEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
                 };
                 component.addKeyListener(listener);
-                
-                return Subscriptions.create(new Action0() {
+
+                subscriber.add(SwingSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
                     @Override
                     public void call() {
                         component.removeKeyListener(listener);
                     }
-                });
+                }));
             }
         });
     }
@@ -115,73 +121,87 @@ public static class UnitTest {
         private Component comp = new JPanel();
         
         @Test
-        public void testObservingKeyEvents() {
-            @SuppressWarnings("unchecked")
-            Action1 action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1 error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            final KeyEvent event = mock(KeyEvent.class);
-            
-            Subscription sub = fromKeyEventsOf(comp).subscribe(action, error, complete);
-            
-            verify(action, never()).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
-            
-            fireKeyEvent(event);
-            verify(action, times(1)).call(Matchers.any());
-            
-            fireKeyEvent(event);
-            verify(action, times(2)).call(Matchers.any());
-            
-            sub.unsubscribe();
-            fireKeyEvent(event);
-            verify(action, times(2)).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
+        public void testObservingKeyEvents() throws Throwable {
+            SwingTestHelper.create().runInEventDispatchThread(new Action0(){
+
+                @Override
+                public void call() {
+                    @SuppressWarnings("unchecked")
+                    Action1 action = mock(Action1.class);
+                    @SuppressWarnings("unchecked")
+                    Action1 error = mock(Action1.class);
+                    Action0 complete = mock(Action0.class);
+
+                    final KeyEvent event = mock(KeyEvent.class);
+
+                    Subscription sub = fromKeyEventsOf(comp).subscribe(action, error, complete);
+
+                    verify(action, never()).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+
+                    fireKeyEvent(event);
+                    verify(action, times(1)).call(Matchers. any());
+
+                    fireKeyEvent(event);
+                    verify(action, times(2)).call(Matchers. any());
+
+                    sub.unsubscribe();
+                    fireKeyEvent(event);
+                    verify(action, times(2)).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+                }
+
+            }).awaitTerminal();
         }
-        
+
         @Test
-        public void testObservingPressedKeys() {
-            @SuppressWarnings("unchecked")
-            Action1> action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1 error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            Subscription sub = currentlyPressedKeysOf(comp).subscribe(action, error, complete);
-            
-            InOrder inOrder = inOrder(action);
-            inOrder.verify(action, times(1)).call(Collections.emptySet());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
-            
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
-            inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
-
-            fireKeyEvent(keyEvent(2, KeyEvent.KEY_PRESSED));
-            fireKeyEvent(keyEvent(KeyEvent.VK_UNDEFINED, KeyEvent.KEY_TYPED));
-            inOrder.verify(action, times(1)).call(new HashSet(asList(1, 2)));
-
-            fireKeyEvent(keyEvent(2, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
-
-            fireKeyEvent(keyEvent(3, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
-
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(Collections.emptySet());
-
-            sub.unsubscribe();
-
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
-            inOrder.verify(action, never()).call(Matchers.>any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
+        public void testObservingPressedKeys() throws Throwable {
+            SwingTestHelper.create().runInEventDispatchThread(new Action0() {
+
+                @Override
+                public void call() {
+                    @SuppressWarnings("unchecked")
+                    Action1> action = mock(Action1.class);
+                    @SuppressWarnings("unchecked")
+                    Action1 error = mock(Action1.class);
+                    Action0 complete = mock(Action0.class);
+
+                    Subscription sub = currentlyPressedKeysOf(comp).subscribe(action, error, complete);
+
+                    InOrder inOrder = inOrder(action);
+                    inOrder.verify(action, times(1)).call(Collections. emptySet());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+
+                    fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
+                    inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+
+                    fireKeyEvent(keyEvent(2, KeyEvent.KEY_PRESSED));
+                    fireKeyEvent(keyEvent(KeyEvent.VK_UNDEFINED, KeyEvent.KEY_TYPED));
+                    inOrder.verify(action, times(1)).call(new HashSet(asList(1, 2)));
+
+                    fireKeyEvent(keyEvent(2, KeyEvent.KEY_RELEASED));
+                    inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
+
+                    fireKeyEvent(keyEvent(3, KeyEvent.KEY_RELEASED));
+                    inOrder.verify(action, times(1)).call(new HashSet(asList(1)));
+
+                    fireKeyEvent(keyEvent(1, KeyEvent.KEY_RELEASED));
+                    inOrder.verify(action, times(1)).call(Collections. emptySet());
+
+                    sub.unsubscribe();
+
+                    fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
+                    inOrder.verify(action, never()).call(Matchers.> any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+                }
+
+            }).awaitTerminal();
         }
 
         private KeyEvent keyEvent(int keyCode, int id) {
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
index 5a26e57251..d14ef8d471 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
@@ -15,7 +15,11 @@
  */
 package rx.swing.sources;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.awt.Component;
 import java.awt.Point;
@@ -30,92 +34,95 @@
 import org.mockito.Matchers;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
-import rx.functions.Func1;
 import rx.functions.Func2;
-import rx.subscriptions.Subscriptions;
+import rx.observables.SwingObservable;
+import rx.subscriptions.SwingSubscriptions;
 
-public enum MouseEventSource { ; // no instances
+public enum MouseEventSource {
+    ; // no instances
 
     /**
      * @see rx.observables.SwingObservable#fromMouseEvents
      */
     public static Observable fromMouseEventsOf(final Component component) {
-        return Observable.create(new OnSubscribeFunc() {
+        return Observable.create(new OnSubscribe() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
+            public void call(final Subscriber subscriber) {
+                SwingObservable.assertEventDispatchThread();
                 final MouseListener listener = new MouseListener() {
                     @Override
                     public void mouseClicked(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void mousePressed(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void mouseReleased(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void mouseEntered(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void mouseExited(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
                 };
                 component.addMouseListener(listener);
-                
-                return Subscriptions.create(new Action0() {
+
+                subscriber.add(SwingSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
                     @Override
                     public void call() {
                         component.removeMouseListener(listener);
                     }
-                });
+                }));
             }
         });
     }
-    
+
     /**
      * @see rx.observables.SwingObservable#fromMouseMotionEvents
      */
     public static Observable fromMouseMotionEventsOf(final Component component) {
-        return Observable.create(new OnSubscribeFunc() {
+        return Observable.create(new OnSubscribe() {
             @Override
-            public Subscription onSubscribe(final Observer observer) {
+            public void call(final Subscriber subscriber) {
+                SwingObservable.assertEventDispatchThread();
                 final MouseMotionListener listener = new MouseMotionListener() {
                     @Override
                     public void mouseDragged(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
 
                     @Override
                     public void mouseMoved(MouseEvent event) {
-                        observer.onNext(event);
+                        subscriber.onNext(event);
                     }
                 };
                 component.addMouseMotionListener(listener);
-                
-                return Subscriptions.create(new Action0() {
+
+                subscriber.add(SwingSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
                     @Override
                     public void call() {
                         component.removeMouseMotionListener(listener);
                     }
-                });
+                }));
             }
         });
     }
-    
+
     /**
      * @see rx.observables.SwingObservable#fromRelativeMouseMotion
      */
@@ -128,48 +135,55 @@ public Point call(MouseEvent ev1, MouseEvent ev2) {
             }
         });
     }
-    
+
     public static class UnitTest {
         private Component comp = new JPanel();
-        
+
         @Test
-        public void testRelativeMouseMotion() {
-            @SuppressWarnings("unchecked")
-            Action1 action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1 error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            Subscription sub = fromRelativeMouseMotion(comp).subscribe(action, error, complete);
-            
-            InOrder inOrder = inOrder(action);
-            
-            verify(action, never()).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
-            
-            fireMouseEvent(mouseEvent(0, 0));
-            verify(action, never()).call(Matchers.any());
-            
-            fireMouseEvent(mouseEvent(10, -5));
-            inOrder.verify(action, times(1)).call(new Point(10, -5));
-            
-            fireMouseEvent(mouseEvent(6, 10));
-            inOrder.verify(action, times(1)).call(new Point(-4, 15));
-            
-            sub.unsubscribe();
-            fireMouseEvent(mouseEvent(0, 0));
-            inOrder.verify(action, never()).call(Matchers.any());
-            verify(error, never()).call(Matchers.any());
-            verify(complete, never()).call();
+        public void testRelativeMouseMotion() throws Throwable {
+            SwingTestHelper.create().runInEventDispatchThread(new Action0() {
+
+                @Override
+                public void call() {
+                    @SuppressWarnings("unchecked")
+                    Action1 action = mock(Action1.class);
+                    @SuppressWarnings("unchecked")
+                    Action1 error = mock(Action1.class);
+                    Action0 complete = mock(Action0.class);
+
+                    Subscription sub = fromRelativeMouseMotion(comp).subscribe(action, error, complete);
+
+                    InOrder inOrder = inOrder(action);
+
+                    verify(action, never()).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+
+                    fireMouseEvent(mouseEvent(0, 0));
+                    verify(action, never()).call(Matchers. any());
+
+                    fireMouseEvent(mouseEvent(10, -5));
+                    inOrder.verify(action, times(1)).call(new Point(10, -5));
+
+                    fireMouseEvent(mouseEvent(6, 10));
+                    inOrder.verify(action, times(1)).call(new Point(-4, 15));
+
+                    sub.unsubscribe();
+                    fireMouseEvent(mouseEvent(0, 0));
+                    inOrder.verify(action, never()).call(Matchers. any());
+                    verify(error, never()).call(Matchers. any());
+                    verify(complete, never()).call();
+                }
+
+            }).awaitTerminal();
         }
-        
+
         private MouseEvent mouseEvent(int x, int y) {
             return new MouseEvent(comp, MouseEvent.MOUSE_MOVED, 1L, 0, x, y, 0, false);
         }
-        
+
         private void fireMouseEvent(MouseEvent event) {
-            for (MouseMotionListener listener: comp.getMouseMotionListeners()) {
+            for (MouseMotionListener listener : comp.getMouseMotionListeners()) {
                 listener.mouseMoved(event);
             }
         }
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java
new file mode 100644
index 0000000000..1b1053ec75
--- /dev/null
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java
@@ -0,0 +1,68 @@
+/**
+ * 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.swing.sources;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import rx.Scheduler.Inner;
+import rx.schedulers.SwingScheduler;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+/* package-private */ final class SwingTestHelper { // only for test
+
+    private final CountDownLatch latch = new CountDownLatch(1);
+    private volatile Throwable error;
+
+    private SwingTestHelper() {
+    }
+
+    public static SwingTestHelper create() {
+        return new SwingTestHelper();
+    }
+
+    public SwingTestHelper runInEventDispatchThread(final Action0 action) {
+        SwingScheduler.getInstance().schedule(new Action1() {
+
+            @Override
+            public void call(Inner inner) {
+                try {
+                    action.call();
+                } catch (Throwable e) {
+                    error = e;
+                }
+                latch.countDown();
+            }
+        });
+        return this;
+    }
+
+    public void awaitTerminal() throws Throwable {
+        latch.await();
+        if (error != null) {
+            throw error;
+        }
+    }
+
+    public void awaitTerminal(long timeout, TimeUnit unit) throws Throwable {
+        latch.await(timeout, unit);
+        if (error != null) {
+            throw error;
+        }
+    }
+
+}

From 3f218d4f111e0e652563710d619f341ae442bee4 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Mon, 17 Feb 2014 23:48:25 -0800
Subject: [PATCH 426/441] Attach Value Without Wrapping

I found a way to pass the value down the chain without wrapping the Throwable. This way it only shows up if using `onErrorFlatMap` or looking at the final cause on any given Throwable.

A final cause will be added so Throwables end up like this:

java.lang.RuntimeException: Forced Failure
	at rx.operators.OperatorMapTest$5.call(OperatorMapTest.java:164)
	at rx.operators.OperatorMapTest$5.call(OperatorMapTest.java:1)
	at rx.operators.OperatorMap$1.onNext(OperatorMap.java:54)
	at rx.operators.OnSubscribeFromIterable.call(OnSubscribeFromIterable.java:43)
	at rx.operators.OnSubscribeFromIterable.call(OnSubscribeFromIterable.java:1)
	at rx.Observable$2.call(Observable.java:269)
	at rx.Observable$2.call(Observable.java:1)
	at rx.Observable$2.call(Observable.java:269)
	at rx.Observable$2.call(Observable.java:1)
	at rx.Observable.subscribe(Observable.java:7022)
	at rx.Observable.subscribe(Observable.java:6945)
	at rx.operators.OperatorMapTest.testMapWithError(OperatorMapTest.java:177)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:606)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: rx.exceptions.OnErrorThrowable$OnNextValue: OnError while emitting onNext value: fail
	at rx.exceptions.OnErrorThrowable.decorate(OnErrorThrowable.java:55)
	at rx.operators.OperatorMap$1.onNext(OperatorMap.java:56)
	... 33 more

Note the final cause: Caused by: rx.exceptions.OnErrorThrowable$OnNextValue: OnError while emitting onNext value: fail

Then when onErrorFlatMap is used, it retrieves that final cause out to create an OnErrorThrowable so people don't have to go fetch it from the cause chain.
---
 .../main/java/rx/exceptions/Exceptions.java   | 44 +++++++++++++++++++
 .../java/rx/exceptions/OnErrorThrowable.java  | 30 +++++++++++--
 .../main/java/rx/operators/OperatorCast.java  |  3 +-
 .../java/rx/operators/OperatorDoOnEach.java   |  2 +-
 .../java/rx/operators/OperatorFilter.java     |  2 +-
 .../java/rx/operators/OperatorGroupBy.java    |  2 +-
 .../main/java/rx/operators/OperatorMap.java   |  2 +-
 .../main/java/rx/operators/OperatorScan.java  |  2 +-
 .../main/java/rx/operators/OperatorZip.java   |  2 +-
 9 files changed, 78 insertions(+), 11 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/exceptions/Exceptions.java b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
index 34f45e52ff..5fccfb2a61 100644
--- a/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
+++ b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
@@ -15,6 +15,9 @@
  */
 package rx.exceptions;
 
+import java.util.HashSet;
+import java.util.Set;
+
 public class Exceptions {
     private Exceptions() {
 
@@ -53,4 +56,45 @@ else if (t instanceof StackOverflowError) {
             throw (LinkageError) t;
         }
     }
+
+    private static final int MAX_DEPTH = 25;
+
+    public static void addCause(Throwable e, Throwable cause) {
+        Set seenCauses = new HashSet();
+
+        int i = 0;
+        while (e.getCause() != null) {
+            if (i++ >= MAX_DEPTH) {
+                // stack too deep to associate cause
+                return;
+            }
+            e = e.getCause();
+            if (seenCauses.contains(e.getCause())) {
+                break;
+            } else {
+                seenCauses.add(e.getCause());
+            }
+        }
+        // we now have 'e' as the last in the chain
+        try {
+            e.initCause(cause);
+        } catch (Throwable t) {
+            // ignore
+            // the javadocs say that some Throwables (depending on how they're made) will never
+            // let me call initCause without blowing up even if it returns null
+        }
+    }
+
+    public static Throwable getFinalCause(Throwable e) {
+        int i = 0;
+        while (e.getCause() != null) {
+            if (i++ >= MAX_DEPTH) {
+                // stack too deep to get final cause
+                return new RuntimeException("Stack too deep to get final cause");
+            }
+            e = e.getCause();
+        }
+        return e;
+    }
+
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
index 16a040c71c..44191afc6c 100644
--- a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -22,13 +22,13 @@ public class OnErrorThrowable extends RuntimeException {
     private final boolean hasValue;
     private final Object value;
 
-    public OnErrorThrowable(Throwable exception) {
+    private OnErrorThrowable(Throwable exception) {
         super(exception);
         hasValue = false;
         this.value = null;
     }
 
-    public OnErrorThrowable(Throwable exception, Object value) {
+    private OnErrorThrowable(Throwable exception, Object value) {
         super(exception);
         hasValue = true;
         this.value = value;
@@ -43,10 +43,32 @@ public boolean isValueNull() {
     }
 
     public static OnErrorThrowable from(Throwable t) {
-        if (t instanceof OnErrorThrowable) {
-            return (OnErrorThrowable) t;
+        Throwable cause = Exceptions.getFinalCause(t);
+        if (cause instanceof OnErrorThrowable.OnNextValue) {
+            return new OnErrorThrowable(t, ((OnNextValue) cause).getValue());
         } else {
             return new OnErrorThrowable(t);
         }
     }
+
+    public static Throwable decorate(Throwable e, Object value) {
+        Exceptions.addCause(e, new OnNextValue(value));
+        return e;
+    }
+
+    public static class OnNextValue extends RuntimeException {
+
+        private static final long serialVersionUID = -3454462756050397899L;
+        private final Object value;
+
+        public OnNextValue(Object value) {
+            super("OnError while emitting onNext value: " + value);
+            this.value = value;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCast.java b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
index 2955d1f647..fcecf382d1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
@@ -17,6 +17,7 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.exceptions.OnErrorThrowable;
 
 /**
@@ -49,7 +50,7 @@ public void onNext(T t) {
                 try {
                     o.onNext(castClass.cast(t));
                 } catch (Throwable e) {
-                    onError(new OnErrorThrowable(e, t));
+                    onError(OnErrorThrowable.decorate(e, t));
                 }
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
index 7a2a813a87..eba6e20104 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
@@ -60,7 +60,7 @@ public void onNext(T value) {
                 try {
                     doOnEachObserver.onNext(value);
                 } catch (Throwable e) {
-                    onError(new OnErrorThrowable(e, value));
+                    onError(OnErrorThrowable.decorate(e, value));
                     return;
                 }
                 observer.onNext(value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index 8a9e07312e..63e6306478 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -54,7 +54,7 @@ public void onNext(T t) {
                         child.onNext(t);
                     }
                 } catch (Throwable e) {
-                    child.onError(new OnErrorThrowable(e, t));
+                    child.onError(OnErrorThrowable.decorate(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 10288ce871..9df8e9e873 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -131,7 +131,7 @@ public void onNext(T t) {
                     // we have the correct group so send value to it
                     gps.onNext(t);
                 } catch (Throwable e) {
-                    onError(new OnErrorThrowable(e, t));
+                    onError(OnErrorThrowable.decorate(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index cb94ee4886..8e7f8bf707 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -53,7 +53,7 @@ public void onNext(T t) {
                 try {
                     o.onNext(transformer.call(t));
                 } catch (Throwable e) {
-                    onError(new OnErrorThrowable(e, t));
+                    onError(OnErrorThrowable.decorate(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
index 5498d7e76d..d4e8f9c9bd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -97,7 +97,7 @@ public void onNext(T value) {
                     try {
                         this.value = accumulator.call(this.value, value);
                     } catch (Throwable e) {
-                        observer.onError(new OnErrorThrowable(e, value));
+                        observer.onError(OnErrorThrowable.decorate(e, value));
                     }
                 }
                 observer.onNext(this.value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 32bacd34ce..b3600bde88 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -194,7 +194,7 @@ void tick() {
                             // all have something so emit
                             observer.onNext(zipFunction.call(vs));
                         } catch (Throwable e) {
-                            observer.onError(new OnErrorThrowable(e, vs));
+                            observer.onError(OnErrorThrowable.decorate(e, vs));
                             return;
                         }
                         // now remove them

From 4328276cf5f287c0062bbf708b6f56729d55def5 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 18 Feb 2014 07:55:23 -0800
Subject: [PATCH 427/441] Refactor to more descriptive name:
 OnErrorThrowable.addValueAsLastCause

---
 .../src/main/java/rx/exceptions/OnErrorThrowable.java    | 9 ++++++++-
 rxjava-core/src/main/java/rx/operators/OperatorCast.java | 2 +-
 .../src/main/java/rx/operators/OperatorDoOnEach.java     | 2 +-
 .../src/main/java/rx/operators/OperatorFilter.java       | 2 +-
 .../src/main/java/rx/operators/OperatorGroupBy.java      | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorMap.java  | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorScan.java | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorZip.java  | 2 +-
 .../src/test/java/rx/operators/OperatorMapTest.java      | 9 ++++++++-
 9 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
index 44191afc6c..7044dd37ca 100644
--- a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -51,7 +51,14 @@ public static OnErrorThrowable from(Throwable t) {
         }
     }
 
-    public static Throwable decorate(Throwable e, Object value) {
+    /**
+     * Adds the given value as the final cause of the given Throwable wrapped in OnNextValue RuntimeException..
+     * 
+     * @param e
+     * @param value
+     * @return Throwable e passed in
+     */
+    public static Throwable addValueAsLastCause(Throwable e, Object value) {
         Exceptions.addCause(e, new OnNextValue(value));
         return e;
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCast.java b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
index fcecf382d1..cbad677443 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
@@ -50,7 +50,7 @@ public void onNext(T t) {
                 try {
                     o.onNext(castClass.cast(t));
                 } catch (Throwable e) {
-                    onError(OnErrorThrowable.decorate(e, t));
+                    onError(OnErrorThrowable.addValueAsLastCause(e, t));
                 }
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
index eba6e20104..150ad112b3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDoOnEach.java
@@ -60,7 +60,7 @@ public void onNext(T value) {
                 try {
                     doOnEachObserver.onNext(value);
                 } catch (Throwable e) {
-                    onError(OnErrorThrowable.decorate(e, value));
+                    onError(OnErrorThrowable.addValueAsLastCause(e, value));
                     return;
                 }
                 observer.onNext(value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
index 63e6306478..76b256c720 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFilter.java
@@ -54,7 +54,7 @@ public void onNext(T t) {
                         child.onNext(t);
                     }
                 } catch (Throwable e) {
-                    child.onError(OnErrorThrowable.decorate(e, t));
+                    child.onError(OnErrorThrowable.addValueAsLastCause(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 9df8e9e873..a8e5ffb53f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -131,7 +131,7 @@ public void onNext(T t) {
                     // we have the correct group so send value to it
                     gps.onNext(t);
                 } catch (Throwable e) {
-                    onError(OnErrorThrowable.decorate(e, t));
+                    onError(OnErrorThrowable.addValueAsLastCause(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index 8e7f8bf707..6418005521 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -53,7 +53,7 @@ public void onNext(T t) {
                 try {
                     o.onNext(transformer.call(t));
                 } catch (Throwable e) {
-                    onError(OnErrorThrowable.decorate(e, t));
+                    onError(OnErrorThrowable.addValueAsLastCause(e, t));
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
index d4e8f9c9bd..2cd8de2626 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -97,7 +97,7 @@ public void onNext(T value) {
                     try {
                         this.value = accumulator.call(this.value, value);
                     } catch (Throwable e) {
-                        observer.onError(OnErrorThrowable.decorate(e, value));
+                        observer.onError(OnErrorThrowable.addValueAsLastCause(e, value));
                     }
                 }
                 observer.onNext(this.value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index b3600bde88..f211e42815 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -194,7 +194,7 @@ void tick() {
                             // all have something so emit
                             observer.onNext(zipFunction.call(vs));
                         } catch (Throwable e) {
-                            observer.onError(OnErrorThrowable.decorate(e, vs));
+                            observer.onError(OnErrorThrowable.addValueAsLastCause(e, vs));
                             return;
                         }
                         // now remove them
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index f54570f893..5cf5cfd1c3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -165,7 +165,14 @@ public String call(String s) {
                 }
                 return s;
             }
-        }));
+        })).doOnError(new Action1() {
+
+            @Override
+            public void call(Throwable t1) {
+                t1.printStackTrace();
+            }
+            
+        });
 
         m.subscribe(stringObserver);
         verify(stringObserver, times(1)).onNext("one");

From 26f8e8350e32256ed64f8323f697ba388690dc82 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 18 Feb 2014 08:11:49 -0800
Subject: [PATCH 428/441] Handle illegal errors thrown from plugin

---
 .../java/rx/observers/SafeSubscriber.java     | 38 +++++++++++++++++--
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index 1158d67b0b..922b61de95 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -117,6 +117,10 @@ public void onNext(T args) {
     protected void _onError(Throwable e) {
         try {
             RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+        } catch (Throwable pluginException) {
+            handlePluginException(pluginException);
+        }
+        try {
             actual.onError(e);
         } catch (Throwable e2) {
             if (e2 instanceof OnErrorNotImplementedException) {
@@ -134,7 +138,11 @@ protected void _onError(Throwable e) {
                 try {
                     unsubscribe();
                 } catch (Throwable unsubscribeException) {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    try {
+                        RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    } catch (Throwable pluginException) {
+                        handlePluginException(pluginException);
+                    }
                     throw new RuntimeException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException)));
                 }
                 throw (OnErrorNotImplementedException) e2;
@@ -144,11 +152,19 @@ protected void _onError(Throwable e) {
                  * 
                  * https://github.com/Netflix/RxJava/issues/198
                  */
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
+                try {
+                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
+                } catch (Throwable pluginException) {
+                    handlePluginException(pluginException);
+                }
                 try {
                     unsubscribe();
                 } catch (Throwable unsubscribeException) {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    try {
+                        RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+                    } catch (Throwable pluginException) {
+                        handlePluginException(pluginException);
+                    }
                     throw new RuntimeException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
                 }
 
@@ -159,11 +175,25 @@ protected void _onError(Throwable e) {
         try {
             unsubscribe();
         } catch (RuntimeException unsubscribeException) {
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+            try {
+                RxJavaPlugins.getInstance().getErrorHandler().handleError(unsubscribeException);
+            } catch (Throwable pluginException) {
+                handlePluginException(pluginException);
+            }
             throw unsubscribeException;
         }
     }
 
+    private void handlePluginException(Throwable pluginException) {
+        /*
+         * We don't want errors from the plugin to affect normal flow.
+         * Since the plugin should never throw this is a safety net
+         * and will complain loudly to System.err so it gets fixed.
+         */
+        System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage());
+        pluginException.printStackTrace();
+    }
+
     public Subscriber getActual() {
         return actual;
     }

From cbabcddee49a1af834514ef1de9171a146923a26 Mon Sep 17 00:00:00 2001
From: Bob T Builder 
Date: Tue, 18 Feb 2014 16:23:01 +0000
Subject: [PATCH 429/441] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC2'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 67948d6fcd..adb9172930 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC2-SNAPSHOT
+version=0.17.0-RC2

From 9b190aea7e72cbfc8c31edecca3dbdf32b2ef633 Mon Sep 17 00:00:00 2001
From: Bob T Builder 
Date: Tue, 18 Feb 2014 16:23:05 +0000
Subject: [PATCH 430/441] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC3-SNAPSHOT'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index adb9172930..95069b4526 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC2
+version=0.17.0-RC3-SNAPSHOT

From 459be62ec13df635b52159ce808597e897ba6b50 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Tue, 18 Feb 2014 20:24:23 -0800
Subject: [PATCH 431/441] GroupBy Unit Test from #900

https://github.com/Netflix/RxJava/issues/900
---
 .../rx/operators/OperatorGroupByTest.java     | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 3d3021190d..d79ff8cb99 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -29,6 +30,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
+import org.mockito.Matchers;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
@@ -932,4 +934,36 @@ public void call(final Subscriber op) {
         });
     };
 
+    @Test
+    public void testGroupByOnAsynchronousSourceAcceptsMultipleSubscriptions() throws InterruptedException {
+
+        // choose an asynchronous source
+        Observable source = Observable.interval(10, TimeUnit.MILLISECONDS).take(1);
+
+        // apply groupBy to the source
+        Observable> stream = source.groupBy(IS_EVEN);
+
+        // create two observers
+        @SuppressWarnings("unchecked")
+        Observer> o1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
+        Observer> o2 = mock(Observer.class);
+
+        // subscribe with the observers
+        stream.subscribe(o1);
+        stream.subscribe(o2);
+
+        // check that subscriptions were successful
+        verify(o1, never()).onError(Matchers. any());
+        verify(o2, never()).onError(Matchers. any());
+    }
+
+    private static Func1 IS_EVEN = new Func1() {
+
+        @Override
+        public Boolean call(Long n) {
+            return n % 2 == 0;
+        }
+    };
+
 }

From d6e78d5ee5dc6c89910f945fac2907bec1b26946 Mon Sep 17 00:00:00 2001
From: Johan Haleby 
Date: Wed, 19 Feb 2014 14:22:41 +0100
Subject: [PATCH 432/441] Fixed NullPointerException that may happen on timeout

---
 .../rx/apache/http/consumers/ResponseConsumerDelegate.java    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerDelegate.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerDelegate.java
index b352ecb61a..24671e7051 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerDelegate.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerDelegate.java
@@ -93,7 +93,9 @@ protected HttpResponse buildResult(HttpContext context) throws Exception {
 
     @Override
     protected void releaseResources() {
-        consumer._releaseResources();
+        if (consumer != null) {
+            consumer._releaseResources();
+        }
     }
 
 }

From ada02c505b05bd77f489c0fcdc670a930e27f76d Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 19 Feb 2014 09:33:01 -0800
Subject: [PATCH 433/441] Scheduler.Recurse fields should be private

---
 rxjava-core/src/main/java/rx/Scheduler.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index fee78c57dd..21d4791f44 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -106,8 +106,8 @@ public void call(Inner inner) {
     }
 
     public static final class Recurse {
-        final Action1 action;
-        final Inner inner;
+        private final Action1 action;
+        private final Inner inner;
 
         private Recurse(Inner inner, Action1 action) {
             this.inner = inner;

From 94c8b6bad01902404c16affbad26f960e37ce178 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 19 Feb 2014 10:02:28 -0800
Subject: [PATCH 434/441] Merge: Unsubscribe Completed Inner Observables

---
 .../java/rx/observers/TestSubscriber.java     |   6 ++
 .../main/java/rx/operators/OperatorMerge.java |  17 ++-
 .../java/rx/operators/OperatorMergeTest.java  | 100 ++++++++++++++++++
 3 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index bf51a2b5b4..50bfabf059 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -85,6 +85,12 @@ public void assertTerminalEvent() {
         testObserver.assertTerminalEvent();
     }
 
+    public void assertUnsubscribed() {
+        if (!isUnsubscribed()) {
+            throw new AssertionError("Not unsubscribed.");
+        }
+    }
+
     public void awaitTerminalEvent() {
         try {
             latch.await();
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index 9425916dac..5b51485224 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -21,6 +21,7 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.observers.SynchronizedSubscriber;
+import rx.subscriptions.CompositeSubscription;
 
 /**
  * Flattens a list of Observables into one Observable sequence, without any transformation.
@@ -36,6 +37,9 @@ public final class OperatorMerge implements Operator> call(final Subscriber outerOperation) {
 
         final Subscriber o = new SynchronizedSubscriber(outerOperation);
+        final CompositeSubscription childrenSubscriptions = new CompositeSubscription();
+        outerOperation.add(childrenSubscriptions);
+
         return new Subscriber>(outerOperation) {
 
             private volatile boolean completed = false;
@@ -57,13 +61,14 @@ public void onError(Throwable e) {
             @Override
             public void onNext(Observable innerObservable) {
                 runningCount.incrementAndGet();
-                innerObservable.subscribe(new InnerObserver());
+                Subscriber i = new InnerObserver();
+                childrenSubscriptions.add(i);
+                innerObservable.subscribe(i);
             }
 
             final class InnerObserver extends Subscriber {
 
                 public InnerObserver() {
-                    super(o);
                 }
 
                 @Override
@@ -71,11 +76,13 @@ public void onCompleted() {
                     if (runningCount.decrementAndGet() == 0 && completed) {
                         o.onCompleted();
                     }
+                    cleanup();
                 }
 
                 @Override
                 public void onError(Throwable e) {
                     o.onError(e);
+                    cleanup();
                 }
 
                 @Override
@@ -83,6 +90,12 @@ public void onNext(T a) {
                     o.onNext(a);
                 }
 
+                private void cleanup() {
+                    // remove subscription onCompletion so it cleans up immediately and doesn't memory leak
+                    // see https://github.com/Netflix/RxJava/issues/897
+                    childrenSubscriptions.remove(this);
+                }
+
             };
 
         };
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 2d150e7af1..4afd9c07b8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -20,6 +20,8 @@
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -32,11 +34,16 @@
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
 
 public class OperatorMergeTest {
@@ -372,4 +379,97 @@ public Subscription onSubscribe(Observer observer) {
         }
     }
 
+    @Test
+    public void testUnsubscribeAsObservablesComplete() {
+        TestScheduler scheduler1 = Schedulers.test();
+        AtomicBoolean os1 = new AtomicBoolean(false);
+        Observable o1 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler1, os1);
+
+        TestScheduler scheduler2 = Schedulers.test();
+        AtomicBoolean os2 = new AtomicBoolean(false);
+        Observable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2);
+
+        TestSubscriber ts = new TestSubscriber();
+        Observable.merge(o1, o2).subscribe(ts);
+
+        // we haven't incremented time so nothing should be received yet
+        ts.assertReceivedOnNext(Collections. emptyList());
+
+        scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
+        scheduler2.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 0L, 1L));
+        // not unsubscribed yet
+        assertFalse(os1.get());
+        assertFalse(os2.get());
+
+        // advance to the end at which point it should complete
+        scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
+
+        ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 0L, 1L, 3L, 4L));
+        assertTrue(os1.get());
+        assertFalse(os2.get());
+
+        // both should be completed now
+        scheduler2.advanceTimeBy(3, TimeUnit.SECONDS);
+
+        ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 0L, 1L, 3L, 4L, 2L, 3L, 4L));
+        assertTrue(os1.get());
+        assertTrue(os2.get());
+
+        ts.assertTerminalEvent();
+    }
+
+    @Test
+    public void testEarlyUnsubscribe() {
+        TestScheduler scheduler1 = Schedulers.test();
+        AtomicBoolean os1 = new AtomicBoolean(false);
+        Observable o1 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler1, os1);
+
+        TestScheduler scheduler2 = Schedulers.test();
+        AtomicBoolean os2 = new AtomicBoolean(false);
+        Observable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2);
+
+        TestSubscriber ts = new TestSubscriber();
+        Subscription s = Observable.merge(o1, o2).subscribe(ts);
+
+        // we haven't incremented time so nothing should be received yet
+        ts.assertReceivedOnNext(Collections. emptyList());
+
+        scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
+        scheduler2.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 0L, 1L));
+        // not unsubscribed yet
+        assertFalse(os1.get());
+        assertFalse(os2.get());
+
+        // early unsubscribe
+        s.unsubscribe();
+
+        assertTrue(os1.get());
+        assertTrue(os2.get());
+
+        ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 0L, 1L));
+        ts.assertUnsubscribed();
+    }
+
+    private Observable createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(final Scheduler scheduler, final AtomicBoolean unsubscribed) {
+        return Observable.create(new OnSubscribe() {
+
+            @Override
+            public void call(Subscriber s) {
+                s.add(Subscriptions.create(new Action0() {
+
+                    @Override
+                    public void call() {
+                        unsubscribed.set(true);
+                    }
+
+                }));
+                Observable.interval(1, TimeUnit.SECONDS, scheduler).take(5).subscribe(s);
+            }
+        });
+    }
+
 }

From d07d9367911d8ec3d0b65846c8707e0a41d1cf1f Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 19 Feb 2014 12:07:03 -0800
Subject: [PATCH 435/441] RxJavaSchedulers Plugin

Allow setting different default schedulers for use by system.
---
 .../main/java/rx/plugins/RxJavaPlugins.java   | 40 ++++++++++++
 .../java/rx/plugins/RxJavaSchedulers.java     | 43 +++++++++++++
 .../rx/plugins/RxJavaSchedulersDefault.java   | 46 ++++++++++++++
 .../main/java/rx/schedulers/Schedulers.java   | 63 ++++++++++++++++---
 4 files changed, 184 insertions(+), 8 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java
 create mode 100644 rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java

diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
index a5384fecee..b09afa7abd 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -31,6 +31,7 @@ public class RxJavaPlugins {
 
     private final AtomicReference errorHandler = new AtomicReference();
     private final AtomicReference observableExecutionHook = new AtomicReference();
+    private final AtomicReference schedulerOverrides = new AtomicReference();
 
     public static RxJavaPlugins getInstance() {
         return INSTANCE;
@@ -149,4 +150,43 @@ private static Object getPluginImplementationViaProperty(Class pluginClass) {
             return null;
         }
     }
+
+    /**
+     * Retrieve instance of {@link RxJavaSchedulers} to use based on order of precedence as defined in {@link RxJavaPlugins} class header.
+     * 
    
+     * Override default by using {@link #registerSchedulers(RxJavaSchedulers)} or setting property: rxjava.plugin.RxJavaDefaultSchedulers.implementation with the full
+     * classname to
+     * load.
+     * 
+     * @return {@link RxJavaErrorHandler} implementation to use
+     */
+    public RxJavaSchedulers getSchedulers() {
+        if (schedulerOverrides.get() == null) {
+            // check for an implementation from System.getProperty first
+            Object impl = getPluginImplementationViaProperty(RxJavaSchedulers.class);
+            if (impl == null) {
+                // nothing set via properties so initialize with default 
+                schedulerOverrides.compareAndSet(null, RxJavaSchedulersDefault.getInstance());
+                // we don't return from here but call get() again in case of thread-race so the winner will always get returned
+            } else {
+                // we received an implementation from the system property so use it
+                schedulerOverrides.compareAndSet(null, (RxJavaSchedulers) impl);
+            }
+        }
+        return schedulerOverrides.get();
+    }
+
+    /**
+     * Register a {@link RxJavaSchedulers} implementation as a global override of any injected or default implementations.
+     * 
+     * @param impl
+     *            {@link RxJavaSchedulers} implementation
+     * @throws IllegalStateException
+     *             if called more than once or after the default was initialized (if usage occurs before trying to register)
+     */
+    public void registerSchedulers(RxJavaSchedulers impl) {
+        if (!schedulerOverrides.compareAndSet(null, impl)) {
+            throw new IllegalStateException("Another strategy was already registered: " + schedulerOverrides.get());
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java b/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java
new file mode 100644
index 0000000000..d346a09b3c
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright 2014 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.plugins;
+
+import rx.Scheduler;
+import rx.functions.Func0;
+
+/**
+ * Define alternate Scheduler implementations to be returned by the `Schedulers` factory methods.
+ * 
    
+ * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: https://github.com/Netflix/RxJava/wiki/Plugins.
+ */
+public abstract class RxJavaSchedulers {
+
+    /**
+     * Factory of Scheduler to return from {@link Schedulers.computation()} or null if default should be used.
+     */
+    public abstract Func0 getComputationScheduler();
+
+    /**
+     * Factory of Scheduler to return from {@link Schedulers.io()} or null if default should be used.
+     */
+    public abstract Func0 getIOScheduler();
+
+    /**
+     * Factory of Scheduler to return from {@link Schedulers.newThread()} or null if default should be used.
+     */
+    public abstract Func0 getNewThreadScheduler();
+}
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java b/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java
new file mode 100644
index 0000000000..40561a819d
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java
@@ -0,0 +1,46 @@
+/**
+ * Copyright 2014 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.plugins;
+
+import rx.Scheduler;
+import rx.functions.Func0;
+
+/**
+ * Default implementation of {@link RxJavaErrorHandler} that does nothing.
+ * 
+ * @ExcludeFromJavadoc
+ */
+public class RxJavaSchedulersDefault extends RxJavaSchedulers {
+
+    private static RxJavaSchedulersDefault INSTANCE = new RxJavaSchedulersDefault();
+
+    public Func0 getComputationScheduler() {
+        return null;
+    }
+
+    public Func0 getIOScheduler() {
+        return null;
+    }
+
+    public Func0 getNewThreadScheduler() {
+        return null;
+    }
+
+    public static RxJavaSchedulers getInstance() {
+        return INSTANCE;
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index bb0a75e358..14fbe08900 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -23,15 +23,62 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
+import rx.functions.Func0;
+import rx.plugins.RxJavaPlugins;
 
 /**
  * Static factory methods for creating Schedulers.
  */
 public class Schedulers {
-    private static final ScheduledExecutorService COMPUTATION_EXECUTOR = createComputationExecutor();
-    private static final Executor IO_EXECUTOR = createIOExecutor();
+
+    private final Func0 computationScheduler;
+    private final Func0 ioScheduler;
+    private final Func0 newThreadScheduler;
+
+    private static final Schedulers INSTANCE = new Schedulers();
 
     private Schedulers() {
+        Func0 c = RxJavaPlugins.getInstance().getSchedulers().getComputationScheduler();
+        if (c != null) {
+            computationScheduler = c;
+        } else {
+            computationScheduler = new Func0() {
+
+                @Override
+                public Scheduler call() {
+                    return executor(createComputationExecutor());
+                }
+
+            };
+        }
+
+        Func0 io = RxJavaPlugins.getInstance().getSchedulers().getIOScheduler();
+        if (io != null) {
+            ioScheduler = io;
+        } else {
+            ioScheduler = new Func0() {
+
+                @Override
+                public Scheduler call() {
+                    return executor(createIOExecutor());
+                }
+
+            };
+        }
+
+        Func0 nt = RxJavaPlugins.getInstance().getSchedulers().getNewThreadScheduler();
+        if (nt != null) {
+            newThreadScheduler = nt;
+        } else {
+            newThreadScheduler = new Func0() {
+
+                @Override
+                public Scheduler call() {
+                    return NewThreadScheduler.getInstance();
+                }
+
+            };
+        }
 
     }
 
@@ -63,14 +110,14 @@ public static Scheduler currentThread() {
     public static Scheduler trampoline() {
         return TrampolineScheduler.getInstance();
     }
-    
+
     /**
      * {@link Scheduler} that creates a new {@link Thread} for each unit of work.
      * 
      * @return {@link NewThreadScheduler} instance
      */
     public static Scheduler newThread() {
-        return NewThreadScheduler.getInstance();
+        return INSTANCE.newThreadScheduler.call();
     }
 
     /**
@@ -107,7 +154,7 @@ public static Scheduler executor(ScheduledExecutorService executor) {
      */
     @Deprecated
     public static Scheduler threadPoolForComputation() {
-        return executor(COMPUTATION_EXECUTOR);
+        return computation();
     }
 
     /**
@@ -120,7 +167,7 @@ public static Scheduler threadPoolForComputation() {
      * @return {@link Scheduler} for computation-bound work.
      */
     public static Scheduler computation() {
-        return executor(COMPUTATION_EXECUTOR);
+        return INSTANCE.computationScheduler.call();
     }
 
     /**
@@ -137,7 +184,7 @@ public static Scheduler computation() {
      */
     @Deprecated
     public static Scheduler threadPoolForIO() {
-        return executor(IO_EXECUTOR);
+        return io();
     }
 
     /**
@@ -152,7 +199,7 @@ public static Scheduler threadPoolForIO() {
      * @return {@link ExecutorScheduler} for IO-bound work.
      */
     public static Scheduler io() {
-        return executor(IO_EXECUTOR);
+        return INSTANCE.ioScheduler.call();
     }
 
     private static ScheduledExecutorService createComputationExecutor() {

From 9178d14d6bb44a1925562c49a2d299b9c9422408 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Wed, 19 Feb 2014 13:33:27 -0800
Subject: [PATCH 436/441] Rename RxJavaSchedulers to RxJavaDefaultSchedulers

Clearer semantic naming.
---
 ...lers.java => RxJavaDefaultSchedulers.java} |  8 ++++----
 ...va => RxJavaDefaultSchedulersDefault.java} | 12 +++++------
 .../main/java/rx/plugins/RxJavaPlugins.java   | 20 +++++++++----------
 .../rx/schedulers/NewThreadScheduler.java     |  5 +++++
 .../main/java/rx/schedulers/Schedulers.java   |  8 ++++----
 5 files changed, 29 insertions(+), 24 deletions(-)
 rename rxjava-core/src/main/java/rx/plugins/{RxJavaSchedulers.java => RxJavaDefaultSchedulers.java} (84%)
 rename rxjava-core/src/main/java/rx/plugins/{RxJavaSchedulersDefault.java => RxJavaDefaultSchedulersDefault.java} (68%)

diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
similarity index 84%
rename from rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java
rename to rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
index d346a09b3c..067df7bc2c 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulers.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
@@ -24,20 +24,20 @@
  * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: https://github.com/Netflix/RxJava/wiki/Plugins.
  */
-public abstract class RxJavaSchedulers {
+public abstract class RxJavaDefaultSchedulers {
 
     /**
      * Factory of Scheduler to return from {@link Schedulers.computation()} or null if default should be used.
      */
-    public abstract Func0 getComputationScheduler();
+    public abstract Func0 getComputationSchedulerFactory();
 
     /**
      * Factory of Scheduler to return from {@link Schedulers.io()} or null if default should be used.
      */
-    public abstract Func0 getIOScheduler();
+    public abstract Func0 getIOSchedulerFactory();
 
     /**
      * Factory of Scheduler to return from {@link Schedulers.newThread()} or null if default should be used.
      */
-    public abstract Func0 getNewThreadScheduler();
+    public abstract Func0 getNewThreadSchedulerFactory();
 }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
similarity index 68%
rename from rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java
rename to rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
index 40561a819d..6e7fa348eb 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaSchedulersDefault.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
@@ -23,23 +23,23 @@
  * 
  * @ExcludeFromJavadoc
  */
-public class RxJavaSchedulersDefault extends RxJavaSchedulers {
+public class RxJavaDefaultSchedulersDefault extends RxJavaDefaultSchedulers {
 
-    private static RxJavaSchedulersDefault INSTANCE = new RxJavaSchedulersDefault();
+    private static RxJavaDefaultSchedulersDefault INSTANCE = new RxJavaDefaultSchedulersDefault();
 
-    public Func0 getComputationScheduler() {
+    public Func0 getComputationSchedulerFactory() {
         return null;
     }
 
-    public Func0 getIOScheduler() {
+    public Func0 getIOSchedulerFactory() {
         return null;
     }
 
-    public Func0 getNewThreadScheduler() {
+    public Func0 getNewThreadSchedulerFactory() {
         return null;
     }
 
-    public static RxJavaSchedulers getInstance() {
+    public static RxJavaDefaultSchedulers getInstance() {
         return INSTANCE;
     }
 
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
index b09afa7abd..408802acb3 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -31,7 +31,7 @@ public class RxJavaPlugins {
 
     private final AtomicReference errorHandler = new AtomicReference();
     private final AtomicReference observableExecutionHook = new AtomicReference();
-    private final AtomicReference schedulerOverrides = new AtomicReference();
+    private final AtomicReference schedulerOverrides = new AtomicReference();
 
     public static RxJavaPlugins getInstance() {
         return INSTANCE;
@@ -152,39 +152,39 @@ private static Object getPluginImplementationViaProperty(Class pluginClass) {
     }
 
     /**
-     * Retrieve instance of {@link RxJavaSchedulers} to use based on order of precedence as defined in {@link RxJavaPlugins} class header.
+     * Retrieve instance of {@link RxJavaDefaultSchedulers} to use based on order of precedence as defined in {@link RxJavaPlugins} class header.
      * 
    
-     * Override default by using {@link #registerSchedulers(RxJavaSchedulers)} or setting property: rxjava.plugin.RxJavaDefaultSchedulers.implementation with the full
+     * Override default by using {@link #registerDefaultSchedulers(RxJavaDefaultSchedulers)} or setting property: rxjava.plugin.RxJavaDefaultSchedulers.implementation with the full
      * classname to
      * load.
      * 
      * @return {@link RxJavaErrorHandler} implementation to use
      */
-    public RxJavaSchedulers getSchedulers() {
+    public RxJavaDefaultSchedulers getDefaultSchedulers() {
         if (schedulerOverrides.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaSchedulers.class);
+            Object impl = getPluginImplementationViaProperty(RxJavaDefaultSchedulers.class);
             if (impl == null) {
                 // nothing set via properties so initialize with default 
-                schedulerOverrides.compareAndSet(null, RxJavaSchedulersDefault.getInstance());
+                schedulerOverrides.compareAndSet(null, RxJavaDefaultSchedulersDefault.getInstance());
                 // we don't return from here but call get() again in case of thread-race so the winner will always get returned
             } else {
                 // we received an implementation from the system property so use it
-                schedulerOverrides.compareAndSet(null, (RxJavaSchedulers) impl);
+                schedulerOverrides.compareAndSet(null, (RxJavaDefaultSchedulers) impl);
             }
         }
         return schedulerOverrides.get();
     }
 
     /**
-     * Register a {@link RxJavaSchedulers} implementation as a global override of any injected or default implementations.
+     * Register a {@link RxJavaDefaultSchedulers} implementation as a global override of any injected or default implementations.
      * 
      * @param impl
-     *            {@link RxJavaSchedulers} implementation
+     *            {@link RxJavaDefaultSchedulers} implementation
      * @throws IllegalStateException
      *             if called more than once or after the default was initialized (if usage occurs before trying to register)
      */
-    public void registerSchedulers(RxJavaSchedulers impl) {
+    public void registerDefaultSchedulers(RxJavaDefaultSchedulers impl) {
         if (!schedulerOverrides.compareAndSet(null, impl)) {
             throw new IllegalStateException("Another strategy was already registered: " + schedulerOverrides.get());
         }
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 96db3f7bcf..78239b79ad 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -46,9 +46,14 @@ public Thread newThread(Runnable r) {
         }
     };
 
+    @Deprecated
     public static NewThreadScheduler getInstance() {
         return INSTANCE;
     }
+    
+    /* package */ static NewThreadScheduler instance() {
+        return INSTANCE;
+    }
 
     private NewThreadScheduler() {
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 14fbe08900..0c607d6bed 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -38,7 +38,7 @@ public class Schedulers {
     private static final Schedulers INSTANCE = new Schedulers();
 
     private Schedulers() {
-        Func0 c = RxJavaPlugins.getInstance().getSchedulers().getComputationScheduler();
+        Func0 c = RxJavaPlugins.getInstance().getDefaultSchedulers().getComputationSchedulerFactory();
         if (c != null) {
             computationScheduler = c;
         } else {
@@ -52,7 +52,7 @@ public Scheduler call() {
             };
         }
 
-        Func0 io = RxJavaPlugins.getInstance().getSchedulers().getIOScheduler();
+        Func0 io = RxJavaPlugins.getInstance().getDefaultSchedulers().getIOSchedulerFactory();
         if (io != null) {
             ioScheduler = io;
         } else {
@@ -66,7 +66,7 @@ public Scheduler call() {
             };
         }
 
-        Func0 nt = RxJavaPlugins.getInstance().getSchedulers().getNewThreadScheduler();
+        Func0 nt = RxJavaPlugins.getInstance().getDefaultSchedulers().getNewThreadSchedulerFactory();
         if (nt != null) {
             newThreadScheduler = nt;
         } else {
@@ -74,7 +74,7 @@ public Scheduler call() {
 
                 @Override
                 public Scheduler call() {
-                    return NewThreadScheduler.getInstance();
+                    return NewThreadScheduler.instance();
                 }
 
             };

From 9c50bdc5f5587dfddf4c09191fae9e8132fbf1ab Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 20 Feb 2014 09:07:52 -0800
Subject: [PATCH 437/441] Remove groupBy with selector.

Use groupBy.map instead.
---
 rxjava-core/src/main/java/rx/Observable.java | 24 --------------------
 1 file changed, 24 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 8079d53532..2224fa3c8e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4589,30 +4589,6 @@ public final  Observable> groupBy(final Func1(keySelector));
     }
 
-    /**
-     * Groups the items emitted by an Observable according to a specified criterion, and emits these grouped
-     * items, transformed by a selector, within {@link GroupedObservable}s, one {@code 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 emitted by 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 transformed items corresponding to items from the source Observable that share
-     *         that key value
-     * @see RxJava Wiki: groupBy
-     */
-    public final  Observable> groupBy(final Func1 keySelector, final Func1 elementSelector) {
-        return null;
-    }
-
     /**
      * Groups the items emitted by an Observable according to a specified key selector function until the
      * duration Observable expires for the key.

From 084ac6fe7a9f34b89d40035f633be8a5ceaf7fdc Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 20 Feb 2014 09:12:16 -0800
Subject: [PATCH 438/441] Deprecate Direct Access to Scheduler Implementations

This enforces the convention of using `Schedulers.*` and then makes the RxJavaDefaultSchedulers plugin more reliable.
---
 .../main/java/rx/schedulers/ExecutorScheduler.java    | 11 ++++++++++-
 .../main/java/rx/schedulers/ImmediateScheduler.java   | 10 +++++++++-
 .../main/java/rx/schedulers/NewThreadScheduler.java   |  8 ++++++--
 .../src/main/java/rx/schedulers/Schedulers.java       |  6 +++---
 .../main/java/rx/schedulers/TrampolineScheduler.java  |  9 +++++++++
 5 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index ed5006aa22..c6f1344320 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -36,10 +36,20 @@
 public class ExecutorScheduler extends Scheduler {
     private final Executor executor;
 
+    /**
+     * @deprecated Use Schedulers.executor();
+     * @return
+     */
+    @Deprecated
     public ExecutorScheduler(Executor executor) {
         this.executor = executor;
     }
 
+    /**
+     * @deprecated Use Schedulers.executor();
+     * @return
+     */
+    @Deprecated
     public ExecutorScheduler(ScheduledExecutorService executor) {
         this.executor = executor;
     }
@@ -50,7 +60,6 @@ public Subscription schedule(Action1 action) {
         inner.schedule(action);
         return inner.innerSubscription;
     }
-    
 
     @Override
     public Subscription schedule(Action1 action, long delayTime, TimeUnit unit) {
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index eca1a2f5d7..e5f5ca6e8a 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -28,10 +28,19 @@
 public final class ImmediateScheduler extends Scheduler {
     private static final ImmediateScheduler INSTANCE = new ImmediateScheduler();
 
+    /**
+     * @deprecated Use Schedulers.immediate();
+     * @return
+     */
+    @Deprecated
     public static ImmediateScheduler getInstance() {
         return INSTANCE;
     }
 
+    /* package */static ImmediateScheduler instance() {
+        return INSTANCE;
+    }
+
     /* package accessible for unit tests */ImmediateScheduler() {
     }
 
@@ -49,7 +58,6 @@ public Subscription schedule(Action1 action, long delayTime, TimeUnit uni
         return inner.innerSubscription;
     }
 
-    
     private class InnerImmediateScheduler extends Scheduler.Inner implements Subscription {
 
         final BooleanSubscription innerSubscription = new BooleanSubscription();
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 78239b79ad..975918f292 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -46,12 +46,16 @@ public Thread newThread(Runnable r) {
         }
     };
 
+    /**
+     * @deprecated Use Schedulers.newThread();
+     * @return
+     */
     @Deprecated
     public static NewThreadScheduler getInstance() {
         return INSTANCE;
     }
-    
-    /* package */ static NewThreadScheduler instance() {
+
+    /* package */static NewThreadScheduler instance() {
         return INSTANCE;
     }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 0c607d6bed..7d2a6a1816 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -88,7 +88,7 @@ public Scheduler call() {
      * @return {@link ImmediateScheduler} instance
      */
     public static Scheduler immediate() {
-        return ImmediateScheduler.getInstance();
+        return ImmediateScheduler.instance();
     }
 
     /**
@@ -99,7 +99,7 @@ public static Scheduler immediate() {
      */
     @Deprecated
     public static Scheduler currentThread() {
-        return TrampolineScheduler.getInstance();
+        return TrampolineScheduler.instance();
     }
 
     /**
@@ -108,7 +108,7 @@ public static Scheduler currentThread() {
      * @return {@link TrampolineScheduler} instance
      */
     public static Scheduler trampoline() {
-        return TrampolineScheduler.getInstance();
+        return TrampolineScheduler.instance();
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index 2539fe4d4a..314a43dc7d 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -30,9 +30,18 @@
 public class TrampolineScheduler extends Scheduler {
     private static final TrampolineScheduler INSTANCE = new TrampolineScheduler();
 
+    /**
+     * @deprecated Use Schedulers.trampoline();
+     * @return
+     */
+    @Deprecated
     public static TrampolineScheduler getInstance() {
         return INSTANCE;
     }
+    
+    /* package */ static TrampolineScheduler instance() {
+        return INSTANCE;
+    }
 
     @Override
     public Subscription schedule(Action1 action) {

From 07ce114ebf0e6a7a190f2e2d708a749dd323dcd1 Mon Sep 17 00:00:00 2001
From: Ben Christensen 
Date: Thu, 20 Feb 2014 09:15:59 -0800
Subject: [PATCH 439/441] Scheduler instances should be or behave like
 singletons

- remove the Func0 factory signature for Scheduler creation.
---
 .../rx/plugins/RxJavaDefaultSchedulers.java   | 19 +++++---
 .../RxJavaDefaultSchedulersDefault.java       | 16 ++++---
 .../main/java/rx/schedulers/Schedulers.java   | 46 +++++--------------
 3 files changed, 33 insertions(+), 48 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
index 067df7bc2c..5adc50e0d1 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
@@ -16,7 +16,6 @@
 package rx.plugins;
 
 import rx.Scheduler;
-import rx.functions.Func0;
 
 /**
  * Define alternate Scheduler implementations to be returned by the `Schedulers` factory methods.
@@ -27,17 +26,23 @@
 public abstract class RxJavaDefaultSchedulers {
 
     /**
-     * Factory of Scheduler to return from {@link Schedulers.computation()} or null if default should be used.
+     * Scheduler to return from {@link Schedulers.computation()} or null if default should be used.
+     * 
+     * This instance should be or behave like a stateless singleton;
      */
-    public abstract Func0 getComputationSchedulerFactory();
+    public abstract Scheduler getComputationScheduler();
 
     /**
-     * Factory of Scheduler to return from {@link Schedulers.io()} or null if default should be used.
+     * Scheduler to return from {@link Schedulers.io()} or null if default should be used.
+     * 
+     * This instance should be or behave like a stateless singleton;
      */
-    public abstract Func0 getIOSchedulerFactory();
+    public abstract Scheduler getIOScheduler();
 
     /**
-     * Factory of Scheduler to return from {@link Schedulers.newThread()} or null if default should be used.
+     * Scheduler to return from {@link Schedulers.newThread()} or null if default should be used.
+     * 
+     * This instance should be or behave like a stateless singleton;
      */
-    public abstract Func0 getNewThreadSchedulerFactory();
+    public abstract Scheduler getNewThreadScheduler();
 }
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
index 6e7fa348eb..b386c25aa6 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulersDefault.java
@@ -16,7 +16,6 @@
 package rx.plugins;
 
 import rx.Scheduler;
-import rx.functions.Func0;
 
 /**
  * Default implementation of {@link RxJavaErrorHandler} that does nothing.
@@ -27,20 +26,23 @@ public class RxJavaDefaultSchedulersDefault extends RxJavaDefaultSchedulers {
 
     private static RxJavaDefaultSchedulersDefault INSTANCE = new RxJavaDefaultSchedulersDefault();
 
-    public Func0 getComputationSchedulerFactory() {
-        return null;
+    public static RxJavaDefaultSchedulers getInstance() {
+        return INSTANCE;
     }
 
-    public Func0 getIOSchedulerFactory() {
+    @Override
+    public Scheduler getComputationScheduler() {
         return null;
     }
 
-    public Func0 getNewThreadSchedulerFactory() {
+    @Override
+    public Scheduler getIOScheduler() {
         return null;
     }
 
-    public static RxJavaDefaultSchedulers getInstance() {
-        return INSTANCE;
+    @Override
+    public Scheduler getNewThreadScheduler() {
+        return null;
     }
 
 }
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 7d2a6a1816..7bbfe61eaa 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -23,7 +23,6 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
-import rx.functions.Func0;
 import rx.plugins.RxJavaPlugins;
 
 /**
@@ -31,53 +30,32 @@
  */
 public class Schedulers {
 
-    private final Func0 computationScheduler;
-    private final Func0 ioScheduler;
-    private final Func0 newThreadScheduler;
+    private final Scheduler computationScheduler;
+    private final Scheduler ioScheduler;
+    private final Scheduler newThreadScheduler;
 
     private static final Schedulers INSTANCE = new Schedulers();
 
     private Schedulers() {
-        Func0 c = RxJavaPlugins.getInstance().getDefaultSchedulers().getComputationSchedulerFactory();
+        Scheduler c = RxJavaPlugins.getInstance().getDefaultSchedulers().getComputationScheduler();
         if (c != null) {
             computationScheduler = c;
         } else {
-            computationScheduler = new Func0() {
-
-                @Override
-                public Scheduler call() {
-                    return executor(createComputationExecutor());
-                }
-
-            };
+            computationScheduler = executor(createComputationExecutor());
         }
 
-        Func0 io = RxJavaPlugins.getInstance().getDefaultSchedulers().getIOSchedulerFactory();
+        Scheduler io = RxJavaPlugins.getInstance().getDefaultSchedulers().getIOScheduler();
         if (io != null) {
             ioScheduler = io;
         } else {
-            ioScheduler = new Func0() {
-
-                @Override
-                public Scheduler call() {
-                    return executor(createIOExecutor());
-                }
-
-            };
+            ioScheduler = executor(createIOExecutor());
         }
 
-        Func0 nt = RxJavaPlugins.getInstance().getDefaultSchedulers().getNewThreadSchedulerFactory();
+        Scheduler nt = RxJavaPlugins.getInstance().getDefaultSchedulers().getNewThreadScheduler();
         if (nt != null) {
             newThreadScheduler = nt;
         } else {
-            newThreadScheduler = new Func0() {
-
-                @Override
-                public Scheduler call() {
-                    return NewThreadScheduler.instance();
-                }
-
-            };
+            newThreadScheduler = NewThreadScheduler.instance();
         }
 
     }
@@ -117,7 +95,7 @@ public static Scheduler trampoline() {
      * @return {@link NewThreadScheduler} instance
      */
     public static Scheduler newThread() {
-        return INSTANCE.newThreadScheduler.call();
+        return INSTANCE.newThreadScheduler;
     }
 
     /**
@@ -167,7 +145,7 @@ public static Scheduler threadPoolForComputation() {
      * @return {@link Scheduler} for computation-bound work.
      */
     public static Scheduler computation() {
-        return INSTANCE.computationScheduler.call();
+        return INSTANCE.computationScheduler;
     }
 
     /**
@@ -199,7 +177,7 @@ public static Scheduler threadPoolForIO() {
      * @return {@link ExecutorScheduler} for IO-bound work.
      */
     public static Scheduler io() {
-        return INSTANCE.ioScheduler.call();
+        return INSTANCE.ioScheduler;
     }
 
     private static ScheduledExecutorService createComputationExecutor() {

From 4851739cbb7d84d7e844f4a826c7dd4353fc1380 Mon Sep 17 00:00:00 2001
From: Bob T Builder 
Date: Thu, 20 Feb 2014 17:38:29 +0000
Subject: [PATCH 440/441] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC3'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 95069b4526..efd9aa7b3f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC3-SNAPSHOT
+version=0.17.0-RC3

From 27c0956b3d6ea79322e2e8c32bcb77df58f32df8 Mon Sep 17 00:00:00 2001
From: Bob T Builder 
Date: Thu, 20 Feb 2014 17:38:33 +0000
Subject: [PATCH 441/441] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC4-SNAPSHOT'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index efd9aa7b3f..80d3fa81f1 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC3
+version=0.17.0-RC4-SNAPSHOT